my tests

modules/ecs6-class/__mocks__/line.js

@@ -0,0 +1,72 @@
+// // Import this named export into your test file:
+//  const mockcalculateSlope= jest.fn().mockImplementation(()=>{
+//     this.slope = 5
+// });
+//  const mockcalculateNOfLineFunction= jest.fn().mockImplementation(()=>{
+//     this.n = 0
+// });
+
+// const mock = jest.fn().mockImplementation(() => {
+//   return {constructor:jest.fn().mockImplementation(()=>{console.log('in mocked constructor of line');}),
+//     calculateSlope: mockcalculateSlope,
+//     calculateNOfLineFunction:mockcalculateNOfLineFunction,
+//     getPointByX:jest.fn().mockImplementation(()=>{
+//         console.log("mocked!!!!!");
+//     })
+//   };
+// });
+
+
+const Point = require("./point");
+
+class MockLine {
+    constructor({ point1 = new Point(), point2 = new Point(), n = undefined, slope = undefined }={}) {
+        this.point1 = point1;
+        this.point2 = point2;
+        this.slope = slope;
+        this.n = n;
+    }
+
+    calculateSlope(){
+        this.slope=2
+        console.log('mocked:)))))))))))');
+        console.log(this.slope);
+        // this.slope = (this.point1.y - this.point2.y) / (this.point1.x - this.point2.x)
+        return
+    }
+
+    calculateNOfLineFunction (){
+        this.n=10
+        // this.n = this.point1.y - this.slope * this.point1.x
+        return
+    }
+
+    getPointOnXAsis() {
+        return this.getPointByY(0)
+    }
+
+    getPointOnYAsis() {
+        return this.getPointByX(0)
+    }
+
+
+    getPointByX(x=0) {
+        if(typeof(x)!='number'){
+            throw new Error('value must be a number')
+        }
+        let y = this.slope * x + this.n
+        return new Point({ x, y })
+    }
+
+    getPointByY(y=0) {
+        if(typeof(y)!='number'){
+            throw new Error('value must be a number')
+        }
+        let x = (y - this.n) / this.slope;
+        return new Point({ x, y })
+    }
+}
+
+
+
+module.exports = MockLine

modules/ecs6-class/__mocks__/point.js

@@ -0,0 +1,20 @@
+class MockPoint {
+    constructor() {
+        this.x = 0;
+        this.y = 0;
+    }
+    moveVertical(value=0 ) {
+        if(typeof(value)!='number'){
+            throw new Error('value must be a number')
+        }
+        this.y += value;
+    }
+    moveHorizontal(value=0) {
+        if(typeof(value)!='number'){
+            throw new Error('value must be a number')
+        }
+        this.x += value;
+    }
+}
+
+module.exports = MockPoint;

modules/ecs6-class/line.js

@@ -1,18 +1,22 @@
 const Point = require("./point");
 
 class Line {
-    constructor({ point1 = new Point(), point2 = new Point(), n = undefined, slope = undefined }) {
+    constructor({ point1 = new Point(), point2 = new Point(), n = undefined, slope = undefined }={}) {
+        if(!(point1 instanceof Point) || !(point2 instanceof Point)){
+            throw new Error('points must be instances of point')
+        }
+
         this.point1 = point1;
         this.point2 = point2;
         this.slope = slope;
-        this.n = n;
+        this.n = n
     }
 
-    calculateSlope = () => {
+    calculateSlope () {
         this.slope = (this.point1.y - this.point2.y) / (this.point1.x - this.point2.x)
     }
 
-    calculateNOfLineFunction = () => {
+    calculateNOfLineFunction(){
         this.n = this.point1.y - this.slope * this.point1.x
     }
 
@@ -25,12 +29,18 @@ class Line {
     }
 
 
-    getPointByX(x) {
+    getPointByX(x=0) {
+        if(typeof(x)!='number'){
+            throw new Error('value must be a number')
+        }
         let y = this.slope * x + this.n
         return new Point({ x, y })
     }
 
-    getPointByY(y) {
+    getPointByY(y=0) {
+        if(typeof(y)!='number'){
+            throw new Error('value must be a number')
+        }
         let x = (y - this.n) / this.slope;
         return new Point({ x, y })
     }

modules/ecs6-class/point.js

@@ -1,14 +1,26 @@
 class Point {
     constructor({x=0, y=0}={}) {
-        this.x = x;
-        this.y = y;
+        if(typeof(x)!='number'||typeof(y)!=='number'){    
+                throw new Error('x and y must be numbers')
+                        }
+        this.x =x;
+        this.y =  y;
+
+
     }
-    moveVertical(value) {
+    moveVertical(value=0 ) {
+        if(typeof(value)!='number'){
+            throw new Error('value must be a number')
+        }
         this.y += value;
     }
-    moveHorizontal(value) {
+    moveHorizontal(value=0) {
+        if(typeof(value)!='number'){
+            throw new Error('value must be a number')
+        }
         this.x += value;
     }
 }
 
-module.exports = Point
+module.exports = Point;
+

modules/geometry-calculation.js

@@ -1,13 +1,23 @@
-const Line = require('./ecs6-class/line')
+const Line = require('./ecs6-class/line');
+const Point = require('./ecs6-class/point');
 
 const calculateDistance = (point1, point2) => {
+
+    if(!point2)
+        throw new Error('must enter 2 points')
+    if(!(point1 instanceof Point)||!(point2 instanceof Point))
+        throw new Error('points must be instances of Point')
     let distanceX = (point2.x - point1.x) ** 2;
-    let distanceY = (point2.y - point2.y) ** 2;
+    let distanceY = (point2.y - point1.y) ** 2;
     const distance = Math.sqrt(distanceX + distanceY);
     return distance;
 }
 
 const calculateJunctionPoint = (line1, line2) => {
+    if(!line2)
+        throw new Error('must enter 2 lines')
+    if(!(line2 instanceof Line)||!(line1 instanceof Line))
+        throw new Error('lines must be instances of Line')
     if (line1.slope === line2.slope) {
         if (line1.n === line2.n) {
             return true
@@ -24,15 +34,23 @@ const calculateJunctionPoint = (line1, line2) => {
 }
 
 const isPointOnLine = (line, point) => {
+    if(!line||!point)
+        throw new Error('must get both line and point')
+    if( !( point instanceof Point))
+        throw new Error('point must be instance of Point')
+    if(! (line instanceof Line))
+        throw new Error('line must be instance of Line')
     const proxyLine = new Line({ point1: line.point1, point2: point })
     proxyLine.calculateSlope()
     if (line.slope === proxyLine.slope) {
         proxyLine.calculateNOfLineFunction()
+
         if (line.n === proxyLine.n) {
             return true
         }
     }
     return false
+
 }
 
 module.exports = {

package.json

@@ -4,7 +4,8 @@
   "description": "practice unit tests in javascript",
   "main": "index.js",
   "scripts": {
-    "test": "jest"
+    "test": "jest",
+    "coverage":"npm test -- --coverage"
   },
   "dependencies": {
     "jest": "^29.7.0"