Implement_check

src/calculator.js

@@ -1,47 +1,33 @@
-exports._check = () => {
+exports._check = (x, y) => {
   // DRY up the codebase with this function
   // First, move the duplicate error checking code here
   // Then, invoke this function inside each of the others
   // HINT: you can invoke this function with exports._check()
-};
-
-exports.add = (x, y) => {
   if (typeof x !== 'number') {
     throw new TypeError(`${x} is not a number`);
   }
   if (typeof y !== 'number') {
     throw new TypeError(`${y} is not a number`);
   }
+};
+
+exports.add = (x, y) => {
+  exports._check(x, y);
   return x + y;
 };
 
 exports.subtract = (x, y) => {
-  if (typeof x !== 'number') {
-    throw new TypeError(`${x} is not a number`);
-  }
-  if (typeof y !== 'number') {
-    throw new TypeError(`${y} is not a number`);
-  }
+  exports._check(x, y);
   return x - y;
 };
 
 exports.multiply = (x, y) => {
-  if (typeof x !== 'number') {
-    throw new TypeError(`${x} is not a number`);
-  }
-  if (typeof y !== 'number') {
-    throw new TypeError(`${y} is not a number`);
-  }
+  exports._check(x, y);
   return x * y;
 };
 
 exports.divide = (x, y) => {
-  if (typeof x !== 'number') {
-    throw new TypeError(`${x} is not a number`);
-  }
-  if (typeof y !== 'number') {
-    throw new TypeError(`${y} is not a number`);
-  }
+  exports._check(x, y);
   return x / y;
 };
 

src/calculator.test.js

@@ -1,20 +1,20 @@
 /* eslint-disable no-unused-expressions */
-const calculator = require('./calculator');
+const calculator = require("./calculator");
 
-describe.skip('_check', () => {
+describe("_check", () => {
   beforeEach(() => {
-    sinon.spy(calculator, '_check');
+    sinon.spy(calculator, "_check");
   });
 
   afterEach(() => {
     calculator._check.restore();
   });
 
-  it('should throw a TypeError if arguments are not numbers', () => {
-    expect(() => calculator._check(40, '2')).to.throw(TypeError);
+  it("should throw a TypeError if arguments are not numbers", () => {
+    expect(() => calculator._check(40, "2")).to.throw(TypeError);
     expect(() => calculator._check(40, [])).to.throw(TypeError);
     expect(() => calculator._check(40, {})).to.throw(TypeError);
-    expect(() => calculator._check('40', 2)).to.throw(TypeError);
+    expect(() => calculator._check("40", 2)).to.throw(TypeError);
     expect(() => calculator._check([], 2)).to.throw(TypeError);
     expect(() => calculator._check({}, 2)).to.throw(TypeError);
   });
@@ -44,94 +44,94 @@ describe.skip('_check', () => {
   });
 });
 
-describe('add', () => {
-  it('should throw a TypeError if arguments are not numbers', () => {
-    expect(() => calculator.add(40, '2')).to.throw(TypeError);
+describe("add", () => {
+  it("should throw a TypeError if arguments are not numbers", () => {
+    expect(() => calculator.add(40, "2")).to.throw(TypeError);
     expect(() => calculator.add(40, [])).to.throw(TypeError);
     expect(() => calculator.add(40, {})).to.throw(TypeError);
-    expect(() => calculator.add('40', 2)).to.throw(TypeError);
+    expect(() => calculator.add("40", 2)).to.throw(TypeError);
     expect(() => calculator.add([], 2)).to.throw(TypeError);
     expect(() => calculator.add({}, 2)).to.throw(TypeError);
   });
 
-  it('should add two positive numbers', () => {
+  it("should add two positive numbers", () => {
     expect(calculator.add(40, 2)).to.equal(42);
   });
 
-  it('should add two negative numbers', () => {
+  it("should add two negative numbers", () => {
     expect(calculator.add(-40, -2)).to.equal(-42);
   });
 
-  it('should add one positive number and one negative number', () => {
+  it("should add one positive number and one negative number", () => {
     expect(calculator.add(44, -2)).to.equal(42);
   });
 });
 
-describe('subtract', () => {
-  it('should throw a TypeError if arguments are not numbers', () => {
-    expect(() => calculator.subtract(40, '2')).to.throw(TypeError);
+describe("subtract", () => {
+  it("should throw a TypeError if arguments are not numbers", () => {
+    expect(() => calculator.subtract(40, "2")).to.throw(TypeError);
     expect(() => calculator.subtract(40, [])).to.throw(TypeError);
     expect(() => calculator.subtract(40, {})).to.throw(TypeError);
-    expect(() => calculator.subtract('40', 2)).to.throw(TypeError);
+    expect(() => calculator.subtract("40", 2)).to.throw(TypeError);
     expect(() => calculator.subtract([], 2)).to.throw(TypeError);
     expect(() => calculator.subtract({}, 2)).to.throw(TypeError);
   });
 
-  it('should subtract two positive numbers', () => {
+  it("should subtract two positive numbers", () => {
     expect(calculator.subtract(44, 2)).to.equal(42);
   });
 
-  it('should subtract two negative numbers', () => {
+  it("should subtract two negative numbers", () => {
     expect(calculator.subtract(-44, -2)).to.equal(-42);
   });
 
-  it('should subtract one positive number and one negative number', () => {
+  it("should subtract one positive number and one negative number", () => {
     expect(calculator.subtract(40, -2)).to.equal(42);
   });
 });
 
-describe('multiply', () => {
-  it('should throw a TypeError if arguments are not numbers', () => {
-    expect(() => calculator.multiply(40, '2')).to.throw(TypeError);
+describe("multiply", () => {
+  it("should throw a TypeError if arguments are not numbers", () => {
+    expect(() => calculator.multiply(40, "2")).to.throw(TypeError);
     expect(() => calculator.multiply(40, [])).to.throw(TypeError);
     expect(() => calculator.multiply(40, {})).to.throw(TypeError);
-    expect(() => calculator.multiply('40', 2)).to.throw(TypeError);
+    expect(() => calculator.multiply("40", 2)).to.throw(TypeError);
     expect(() => calculator.multiply([], 2)).to.throw(TypeError);
     expect(() => calculator.multiply({}, 2)).to.throw(TypeError);
   });
 
-  it('should multiply two positive numbers', () => {
+  it("should multiply two positive numbers", () => {
     expect(calculator.multiply(6, 7)).to.equal(42);
   });
 
-  it('should multiply two negative numbers', () => {
+  it("should multiply two negative numbers", () => {
     expect(calculator.multiply(-6, -7)).to.equal(42);
   });
 
-  it('should multiply one positive number and one negative number', () => {
+  it("should multiply one positive number and one negative number", () => {
     expect(calculator.multiply(6, -7)).to.equal(-42);
   });
 });
 
-describe('divide', () => {
-  it('should throw a TypeError if arguments are not numbers', () => {
-    expect(() => calculator.divide(40, '2')).to.throw(TypeError);
+describe("divide", () => {
+  it("should throw a TypeError if arguments are not numbers", () => {
+    expect(() => calculator.divide(40, "2")).to.throw(TypeError);
     expect(() => calculator.divide(40, [])).to.throw(TypeError);
     expect(() => calculator.divide(40, {})).to.throw(TypeError);
-    expect(() => calculator.divide('40', 2)).to.throw(TypeError);
+    expect(() => calculator.divide("40", 2)).to.throw(TypeError);
     expect(() => calculator.divide([], 2)).to.throw(TypeError);
     expect(() => calculator.divide({}, 2)).to.throw(TypeError);
   });
 
-  it('should divide two positive numbers', () => {
+  it("should divide two positive numbers", () => {
     expect(calculator.divide(84, 2)).to.equal(42);
   });
 
-  it('should divide two negative numbers', () => {
+  it("should divide two negative numbers", () => {
     expect(calculator.divide(-84, -2)).to.equal(42);
   });
 
-  it('should divide one positive number and one negative number', () => {
+  it("should divide one positive number and one negative number", () => {
     expect(calculator.divide(84, -2)).to.equal(-42);
   });
 });