--fix: eslint & increase code coverage near 100%

Author: TheSTL

src/_DataStructures_/Trees/BinarySearchTree/BinarySearchTree.test.js

@@ -0,0 +1,28 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Is Empty', () => {
+    const bst = new BinarySearchTree(6);
+    bst.add(4);
+    bst.add(9);
+    bst.add(2);
+    bst.add(5);
+    bst.add(8);
+    bst.add(12);
+    it('should return False', () => {
+      expect(bst.isEmpty()).toEqual(false);
+    });
+
+    it('should return True', () => {
+      bst.remove(6);
+      bst.remove(4);
+      bst.remove(9);
+      bst.remove(2);
+      bst.remove(5);
+      bst.remove(8);
+      bst.remove(12);
+      
+      expect(bst.isEmpty()).toEqual(true);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-isEmpty.test.js

@@ -0,0 +1,21 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Find maximum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+    bst.add(4);
+    bst.add(9);
+    bst.add(2);
+    bst.add(5);
+    bst.add(8);
+    bst.add(12);
+    it('should return 12', () => {
+      expect(bst.getMaximum()).toEqual(12);
+    });
+
+    it('should return 20', () => {
+      bst.add(20);
+      expect(bst.getMaximum()).toEqual(20);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-maximum.test.js

@@ -0,0 +1,21 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Find minimum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+    bst.add(4);
+    bst.add(9);
+    bst.add(2);
+    bst.add(5);
+    bst.add(8);
+    bst.add(12);
+    it('should return 4', () => {      
+      expect(bst.getMinimum()).toEqual(2);
+    });
+
+    it('should return 1', () => {
+      bst.add(1);
+      expect(bst.getMinimum()).toEqual(1);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-minimum.test.js

@@ -0,0 +1,32 @@
+const BST = require('.');
+
+describe('Data Structure : Binary Search Tree', () => {
+  it('Should be class', () => {
+    expect(typeof BST.prototype.constructor).toEqual('function');
+  });
+
+  describe('Binary Search Tree API', () => {
+    let bst = null;
+
+    beforeEach(() => {
+      bst = new BST(5);
+    });
+
+    it('Should delete() an element from Binary Search Tree', () => {
+      bst.add(4);
+      bst.add(9);
+      bst.add(2);
+      bst.delete(bst.root, 4);
+      expect(bst.traverseInorder()).toEqual([2, 5, 9]);
+      bst.delete(bst.root, 2);
+      expect(bst.traverseInorder()).toEqual([5, 9]);
+    });
+
+    it('Should return NULL if root is empty', () => {
+      const bst2 = new BST(6);
+      bst2.remove(6);
+      bst2.remove(9);
+      expect(bst2.root).toEqual(null);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-remove.test.js

@@ -0,0 +1,21 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  describe('Find maximum value in BST', () => {
+    const bst = new BinarySearchTree(6);
+
+    bst.add(4);
+    bst.add(9);
+    bst.add(2);
+    bst.add(5);
+    bst.add(8);
+    bst.add(12);
+    it('search for 8', () => {
+      expect(bst.searchFor(8)).toEqual(true);
+    });
+
+    it('search for 100', () => {
+      expect(bst.searchFor(100)).toEqual(false);
+    });
+  });
+});

src/_DataStructures_/Trees/BinarySearchTree/bst-search.test.js

@@ -1,5 +1,5 @@
-const BinarySearchTree = require('./index');
-const heightOfBST = require('./height-of-bst/index');
+const BinarySearchTree = require('../index');
+const heightOfBST = require('./index');
 
 describe('Binary search tree traversals', () => {
   let bst;
@@ -48,4 +48,20 @@ describe('Binary search tree traversals', () => {
       expect(heightOfBST(bst.root)).toEqual(2);
     });
   });
+
+  describe('Check bst was created as expected', () => {
+    const bst2 = new BinarySearchTree(10);
+    bst2.add(11);
+    bst2.add(20);
+    bst2.add(9);
+    bst2.add(8);
+    bst2.add(7);
+    bst2.add(6);
+    bst2.add(5);
+    bst2.add(4);
+
+    it('Height should be 7', () => {
+      expect(heightOfBST(bst2.root)).toEqual(7);
+    });
+  });
 });

src/_DataStructures_/Trees/BinarySearchTree/bst-deletion.test.js renamed to src/_DataStructures_/Trees/BinarySearchTree/height-of-bst/height-of-bst.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable consistent-return */
 const Node = require('./Node');
 
 class BinarySearchTree {
@@ -23,7 +24,6 @@ class BinarySearchTree {
       root.rightChild = this.insert(root.rightChild, value);
       return root;
     }
-    return root;
   }
 
   preorder(root) {
@@ -80,7 +80,6 @@ class BinarySearchTree {
     if (value > root.value) {
       return this.search(root.rightChild, value);
     }
-    return false;
   }
 
   delete(root, value) {