Merge pull request #5 from 403-html/JCC-4-add-jest-tests

[JCC-4] Add Jest tests

Author: Tymoteusz

.gitignore

@@ -1,6 +1,6 @@
 # Node modules
 node_modules
 
-# Jest coverage folder
+# Jest
 coverage
-result.json
+result.json

RandSum0/README.md

@@ -1,7 +1,11 @@
 # Random N-numbers sum which is equal to 0
-Write a function that as an argument gets the integer N. (1 <N <100).
-This function is to return an array that contains unique N random numbers in the range -100 to 100, and besides that the sum of these numbers must always go to 0. For example, for N = 4 array [-1, -2.0.3]
 
--------
+Write a function that as an argument gets the integer N `(1 < N < 100)`.
 
-**Enjoy**
+This function is to return an `array` that contains unique `N` random numbers in the range `-100` to `100`, and besides that the sum of these numbers must always go to `0`.
+
+For example, for `N = 4` array `[-1, -2, 0, 3]`
+
+---
+
+**Enjoy**

RandSum0/__tests__/randsum.spec.js

@@ -0,0 +1,35 @@
+const genSum = require('../index')
+
+const sumArrElems = (arr) => arr.reduce((a, b) => a + b)
+
+test('Providing "0" as argument should give an array that\'s empty', () => {
+    const arrayLength = 0
+    const randomArray = new genSum(arrayLength).array
+
+    expect(randomArray.length).toBe(arrayLength)
+    expect(randomArray).toEqual([])
+})
+
+test('Providing "1" as argument should give an array that contains "0"', () => {
+    const arrayLength = 1
+    const randomArray = new genSum(arrayLength).array
+
+    expect(randomArray.length).toBe(arrayLength)
+    expect(randomArray[0]).toEqual(0)
+})
+
+test('Array should have length 4, and values should sum to 0', () => {
+    const arrayLength = 4
+    const randomArray = new genSum(arrayLength).array
+
+    expect(randomArray.length).toBe(arrayLength)
+    expect(sumArrElems(randomArray)).toEqual(0)
+})
+
+test('Array should have length 17, and values should sum to 0', () => {
+    const arrayLength = 17
+    const randomArray = new genSum(arrayLength).array
+
+    expect(randomArray.length).toBe(arrayLength)
+    expect(sumArrElems(randomArray)).toEqual(0)
+})

RandSum0/index.html

@@ -1,7 +1,13 @@
 class genSum {
     constructor(n) {
         this.array = []
-        if (n > 0) this.toss(n)
+        if (n > 0) {
+            if (n === 1) {
+                this.array.push(0)
+            } else {
+                this.toss(n)
+            }
+        }
     }
     toss(n) {
         if (n) {
@@ -41,3 +47,5 @@ class genSum {
         }
     }
 }
+
+module.exports = genSum

RandSum0/index.js

@@ -1,19 +1,28 @@
 # Binary tree
+
 You have to build a simple binary tree (there can only be a node of this tree in the console or you can plot it with HTML/CSS)
 
 Basic principles:
-- left = smaller
-  - for each node
-- right = greater
-  - for each node
-- (optional) adding an option to automatically sort numbers from the lowest to the highest (sorting by searching the tree, not by other sorting)
-- they must work for all integers
-- adding the possibility of adding new values to the tree
+
+-   left = smaller
+    -   for each node
+-   right = greater
+    -   for each node
+-   they must work for all integers
+-   adding the possibility of adding new values to the tree
+-   tree should have that properties
+    -   each node should have properties
+        -   "number"
+        -   "nodeIndex"
+        -   "left"
+        -   "right"
+    -   root node should have properties
+        -   "valueIndex" (counting how many values were provided after "root" node get it's value)
 
 Helpful links:
 
 [What is binary tree](https://en.wikipedia.org/wiki/Binary_tree)
 
--------
+---
 
 **Enjoy**

binary-tree/README.md

@@ -0,0 +1,50 @@
+const fs = require('fs')
+
+const Tree = require('../tree')
+const fixtures = JSON.parse(fs.readFileSync(__dirname + '/fixtures.json'))
+
+const getTreeOf = (arr) => {
+    const tree = new Tree()
+
+    arr.forEach((elem) => tree.addValue(elem))
+
+    return tree
+}
+
+test('empty input should get empty obj', () => {
+    expect(getTreeOf(fixtures.zero.input)).toEqual(fixtures.zero.output)
+})
+
+test('one input should match output tree', () => {
+    expect(getTreeOf(fixtures.one.input)).toEqual(fixtures.one.output)
+})
+
+test('one-smaller input should match output tree', () => {
+    expect(getTreeOf(fixtures['one-smaller'].input)).toEqual(
+        fixtures['one-smaller'].output
+    )
+})
+
+test('one-greater input should match output tree', () => {
+    expect(getTreeOf(fixtures['one-greater'].input)).toEqual(
+        fixtures['one-greater'].output
+    )
+})
+
+test('greater-and-lower input should match output tree', () => {
+    expect(getTreeOf(fixtures['greater-and-lower'].input)).toEqual(
+        fixtures['greater-and-lower'].output
+    )
+})
+
+test('inherit-greater input should match output tree', () => {
+    expect(getTreeOf(fixtures['inherit-greater'].input)).toEqual(
+        fixtures['inherit-greater'].output
+    )
+})
+
+test('many-values input should match output tree', () => {
+    expect(getTreeOf(fixtures['many-values'].input)).toEqual(
+        fixtures['many-values'].output
+    )
+})

binary-tree/__tests__/binary-tree.spec.js

@@ -0,0 +1,116 @@
+{
+    "zero": {
+        "input": [],
+        "output": {}
+    },
+    "one": {
+        "input": [1],
+        "output": { "number": 1, "nodeIndex": 0 }
+    },
+    "one-smaller": {
+        "input": [2, 1],
+        "output": {
+            "number": 2,
+            "nodeIndex": 0,
+            "valueIndex": 1,
+            "left": { "number": 1, "nodeIndex": 1 }
+        }
+    },
+    "one-greater": {
+        "input": [2, 3],
+        "output": {
+            "number": 2,
+            "nodeIndex": 0,
+            "valueIndex": 1,
+            "right": { "number": 3, "nodeIndex": 1 }
+        }
+    },
+    "greater-and-lower": {
+        "input": [2, 3, 1],
+        "output": {
+            "number": 2,
+            "nodeIndex": 0,
+            "valueIndex": 2,
+            "right": { "number": 3, "nodeIndex": 1 },
+            "left": { "number": 1, "nodeIndex": 2 }
+        }
+    },
+    "inherit-lower": {
+        "input": [4, 3, 2],
+        "output": {
+            "number": 4,
+            "nodeIndex": 0,
+            "valueIndex": 2,
+            "left": {
+                "number": 3,
+                "nodeIndex": 1,
+                "left": { "number": 2, "nodeIndex": 2 }
+            }
+        }
+    },
+    "inherit-greater": {
+        "input": [2, 3, 4],
+        "output": {
+            "number": 2,
+            "nodeIndex": 0,
+            "valueIndex": 2,
+            "right": {
+                "number": 3,
+                "nodeIndex": 1,
+                "right": { "number": 4, "nodeIndex": 2 }
+            }
+        }
+    },
+    "many-values": {
+        "input": [18, 5, 26, 13, 7, 30, 36, 11, 2, 40, 15, 4],
+        "output": {
+            "number": 18,
+            "nodeIndex": 0,
+            "valueIndex": 11,
+            "left": {
+                "number": 5,
+                "nodeIndex": 1,
+                "right": {
+                    "number": 13,
+                    "nodeIndex": 3,
+                    "left": {
+                        "number": 7,
+                        "nodeIndex": 4,
+                        "right": {
+                            "number": 11,
+                            "nodeIndex": 7
+                        }
+                    },
+                    "right": {
+                        "number": 15,
+                        "nodeIndex": 10
+                    }
+                },
+                "left": {
+                    "number": 2,
+                    "nodeIndex": 8,
+                    "right": {
+                        "number": 4,
+                        "nodeIndex": 11
+                    }
+                }
+            },
+            "right": {
+                "number": 26,
+                "nodeIndex": 2,
+                "right": {
+                    "number": 30,
+                    "nodeIndex": 5,
+                    "right": {
+                        "number": 36,
+                        "nodeIndex": 6,
+                        "right": {
+                            "number": 40,
+                            "nodeIndex": 9
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

binary-tree/__tests__/fixtures.json

@@ -1,10 +1,10 @@
 class Tree {
     constructor() {}
     addValue(value) {
-        if (!this.number) {
+        if (!this.number && value) {
             this.number = value
             this.nodeIndex = 0
-        } else {
+        } else if (this.number && value) {
             if (this.valueIndex) this.valueIndex += 1
             else this.valueIndex = 1
             // right, higher
@@ -39,3 +39,5 @@ class Branch {
         }
     }
 }
+
+module.exports = Tree