added tests for the current modules.

Author: markhatchell

.gitignore

@@ -1,3 +1,4 @@
 .idea
 node_modules
-lib
+lib
+/coverage

.npmignore

@@ -1 +1,3 @@
-.idea
+.idea
+*.test.js
+/coverage

package.json

@@ -4,10 +4,13 @@
   "description": "This is an ES6/ES2015 library of Electrical Engineering Equations",
   "main": "lib/index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest --coverage",
     "build": "babel src --out-dir lib --source-maps",
     "prepublish": "npm run build"
   },
+  "jest": {
+    "testEnvironment": "node"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/markhatchell/JS-Electrical-Engineering-Equations.git"
@@ -25,6 +28,7 @@
   "devDependencies": {
     "babel-cli": "^6.26.0",
     "babel-plugin-transform-es2015-block-scoping": "^6.26.0",
-    "babel-preset-env": "^1.6.1"
+    "babel-preset-env": "^1.6.1",
+    "jest-cli": "^22.1.4"
   }
 }

src/Ohms-Law.test.js

@@ -0,0 +1,48 @@
+const OhmsLaw = require('./Ohms-Law').default;
+
+
+describe('OhmsLaw', () => {
+
+  test('if current is .5 and volts are 10 then resistance should be 20 and wattage should be 5', () => {
+    expect(OhmsLaw.calcWattsResistance(.5, 10)).toEqual({
+      resistance: 20,
+      watts: 5
+    })
+  });
+
+  test('if current is .5 and resistance is 20 then volts should be 10 and wattage should be 5', () => {
+    expect(OhmsLaw.calcWattsVoltage(20, .5)).toEqual({
+      voltage: 10,
+      watts: 5
+    })
+  });
+
+  test('if current is .5 and wattage is 5 then resistance should be 20 and voltage should be 10', () => {
+    expect(OhmsLaw.calcVoltageResistance(.5, 5)).toEqual({
+      voltage: 10,
+      resistance: 20
+    })
+  });
+
+  test('if wattage is 5 and volts are 10 then resistance should be 20 and current should be .5', () => {
+    expect(OhmsLaw.calcCurrentResistance(5, 10)).toEqual({
+      resistance: 20,
+      current: .5
+    })
+  });
+
+  test('if wattage is 5 and resistance is 20 then voltage should be 10 and current should be .5', () => {
+    expect(OhmsLaw.calcVoltageCurrent(20, 5)).toEqual({
+      voltage: 10,
+      current: .5
+    })
+  });
+
+  test('if volts are 10 and resistance is 20 then watts should be 5 and current should be .5', () => {
+    expect(OhmsLaw.calcWattsCurrent(20, 10)).toEqual({
+      watts: 5,
+      current: .5
+    })
+  });
+
+});

src/Tank-Circuit.test.js

@@ -0,0 +1,29 @@
+const TankCircuit = require('./Tank-Circuit').default;
+
+
+describe('TankCircuit', () => {
+
+  test('if InductanceInNanoHenries is 50 and CapacitanceInPicoFarads is 50 then calculatedFrequencyInHertz should be 100658424.20897408', () => {
+    const inductance  = parseFloat(50) / 1000000000;
+    const capacitance = parseFloat(50) / 1000000000000;
+
+    expect(TankCircuit.calcFrequency(inductance, capacitance).calculatedFrequencyInHertz).toEqual(100658424.20897408)
+  });
+
+  test('if frequency in Hertz is 100658424.20897408 and CapacitanceInPicoFarads is 50 then calculatedInductanceInHenries should be 0.000000050', () => {
+    const frequency  = 100658424.20897408;
+    const capacitance = parseFloat(50) / 1000000000000;
+
+    expect(TankCircuit.calcInductance(frequency, capacitance).calculatedInductanceInHenries).toEqual(0.000000050)
+  });
+
+  test('if frequency in Hertz is 100658424.20897408 and InductanceInNanoHenries is 50 then calculatedCapacitanceInFarads should be 0.000000000050', () => {
+    const frequency  = 100658424.20897408;
+    const inductance  = parseFloat(50) / 1000000000;
+
+    expect(TankCircuit.calcCapacitance(frequency, inductance).calculatedCapacitanceInFarads).toEqual(0.000000000050)
+  });
+
+
+
+});

src/Wavelength.js

@@ -25,7 +25,7 @@ function metersToInches(meters, precision = 4) {
 class Wavelength {
   constructor(frequencyInMegahertz, precision = 4) {
     if (typeof frequencyInMegahertz === 'undefined') {
-      throw Error('Need a frequency to init a Wavelength');
+      throw new Error('Need a frequency to init a Wavelength');
     }
     this.frequencyInMegahertz = parseFloat(frequencyInMegahertz);
     this.valueInMeters = 300 / this.frequencyInMegahertz;
@@ -36,6 +36,10 @@ class Wavelength {
     return this.valueInMeters.toPrecision(this.precision);
   }
 
+  toFloat() {
+    return parseFloat(this.valueInMeters.toPrecision(this.precision));
+  }
+
   setPrecision(p) {
     this.precision = p;
   }
@@ -108,7 +112,7 @@ class Wavelength {
         return metersToInches(quaterWavelength, this.precision);
     }
   }
-  
+
 }
 
 

src/Wavelength.test.js

@@ -0,0 +1,163 @@
+const Wavelength = require('./Wavelength').default;
+
+
+describe('Wavelength', () => {
+  let wavelength = new Wavelength('300');
+
+  test('should throw error when initialized with out a frequency', () => {
+    expect(() => {
+      new Wavelength()
+    }).toThrowError('Need a frequency to init a Wavelength');
+  });
+
+
+  test('should initialize with a wavelength and output as string', () => {
+    expect(wavelength.toString()).toEqual("1.000");
+  });
+
+  test('should initialize with a wavelength and output as float', () => {
+    expect(wavelength.toFloat()).toEqual(1.0);
+  });
+
+  test('should set precision to 1', () => {
+    wavelength.setPrecision(1);
+    expect(wavelength.toString()).toEqual("1");
+    wavelength.setPrecision(4);
+  });
+
+  // meters tests
+  test('should show full wavelength in meters as 1.000', () => {
+    expect(wavelength.toString()).toEqual("1.000");
+    expect(wavelength.toFloat()).toEqual(1.000);
+  });
+
+  test('should show three quarters wavelength in meters as 0.7500', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toThreeQuartersWavelength('m')).toEqual("0.7500");
+    expect(parseFloat(wavelength.toThreeQuartersWavelength('m'))).toEqual(0.7500);
+  });
+
+  test('should show five eighths half wavelength in meters as 0.6250', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toFiveEighthsWavelength('m')).toEqual("0.6250");
+    expect(parseFloat(wavelength.toFiveEighthsWavelength('m'))).toEqual(0.6250);
+  });
+
+  test('should show one half wavelength in meters as 0.5000', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toHalfWavelength('m')).toEqual("0.5000");
+    expect(parseFloat(wavelength.toHalfWavelength('m'))).toEqual(0.5000);
+  });
+
+  test('should show one quarter wavelength in meters as 0.2500', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toQuarterWavelength('m')).toEqual("0.2500");
+    expect(parseFloat(wavelength.toQuarterWavelength('m'))).toEqual(0.2500);
+  });
+
+  // centimeters tests
+  test('should show full wavelength in centimeters as 100.0', () => {
+    expect(wavelength.toCentimeters()).toEqual("100.0");
+    expect(parseFloat(wavelength.toCentimeters())).toEqual(100);
+  });
+
+  test('should show three quarters wavelength in centimeters as 75.00', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toThreeQuartersWavelength('cm')).toEqual("75.00");
+    expect(parseFloat(wavelength.toThreeQuartersWavelength('cm'))).toEqual(75.00);
+  });
+
+  test('should show five eighths half wavelength in centimeters as 62.50', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toFiveEighthsWavelength('cm')).toEqual("62.50");
+    expect(parseFloat(wavelength.toFiveEighthsWavelength('cm'))).toEqual(62.50);
+  });
+
+  test('should show one half wavelength in centimeters as 50.00', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toHalfWavelength('cm')).toEqual("50.00");
+    expect(parseFloat(wavelength.toHalfWavelength('cm'))).toEqual(50.00);
+  });
+
+  test('should show one quarter wavelength in centimeters as 25.00', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toQuarterWavelength('cm')).toEqual("25.00");
+    expect(parseFloat(wavelength.toQuarterWavelength('cm'))).toEqual(25.00);
+  });
+
+  // feet tests
+
+  test('should show full wavelength in feet as 3.281', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toFeet()).toEqual("3.281");
+    expect(parseFloat(wavelength.toFeet())).toEqual(3.281);
+  });
+
+  test('should show three quarters wavelength in feet as 2.4611', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toThreeQuartersWavelength('f')).toEqual("2.461");
+    expect(parseFloat(wavelength.toThreeQuartersWavelength('f'))).toEqual(2.461);
+  });
+
+  test('should show five eighths half wavelength in feet as 2.051', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toFiveEighthsWavelength('f')).toEqual("2.051");
+    expect(parseFloat(wavelength.toFiveEighthsWavelength('f'))).toEqual(2.051);
+  });
+
+  test('should show one half wavelength in feet as 1.640', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toHalfWavelength('f')).toEqual("1.640");
+    expect(parseFloat(wavelength.toHalfWavelength('f'))).toEqual(1.640);
+  });
+
+  test('should show one quarter wavelength in feet as 0.8202', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toQuarterWavelength('f')).toEqual("0.8202");
+    expect(parseFloat(wavelength.toQuarterWavelength('f'))).toEqual(0.8202);
+  });
+
+
+  // inches tests
+
+  test('should show full wavelength in inches as 39.37', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toInches()).toEqual("39.37");
+    expect(parseFloat(wavelength.toInches())).toEqual(39.37);
+  });
+
+  test('should show three quarters wavelength in feet as 29.53', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toThreeQuartersWavelength('in')).toEqual("29.53");
+    expect(parseFloat(wavelength.toThreeQuartersWavelength('in'))).toEqual(29.53);
+  });
+
+  test('should show five eighths half wavelength in feet as 24.61', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toFiveEighthsWavelength('in')).toEqual("24.61");
+    expect(parseFloat(wavelength.toFiveEighthsWavelength('in'))).toEqual(24.61);
+  });
+
+  test('should show one half wavelength in feet as 19.69', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toHalfWavelength('in')).toEqual("19.69");
+    expect(parseFloat(wavelength.toHalfWavelength('in'))).toEqual(19.69);
+  });
+
+  test('should show one quarter wavelength in feet as 9.843', () => {
+    wavelength.setPrecision(4);
+    expect(wavelength.toQuarterWavelength('in')).toEqual("9.843");
+    expect(parseFloat(wavelength.toQuarterWavelength('in'))).toEqual(9.843);
+  });
+
+
+
+
+  // test('if current is .5 and volts are 10 then resistance should be 20 and wattage should be 5', () => {
+  //   expect(OhmsLaw.calcWattsResistance(.5, 10)).toEqual({
+  //     resistance: 20,
+  //     watts: 5
+  //   })
+  // });
+
+});