Js promise for calculator

Question

I have a simple calculator function that I wrote for a coding challenge. Now I'm having trouble with an additional calculate function that should return a promise.

class Calculator{
    constructor(){
        this[Symbol.toStringTag] = 'Calculator'; 
    } 
    add(a, b) {
        return a + b; 
    } 
    subtract(a, b) {
        return a - b; 
    }  
    multiply(a, b) {
        return a * b;
    } 
    divide(a, b) {
        if(b === 0){ 
            return NaN;
        }
        return a / b; 
    }
    toString(){
        return "Calculator";
    }
    calculate(...args) {
        var result = 0;
        return new Promise(function(resolve, reject){
            setTimeout(function() {
                if(result === NaN) {
                   reject(NaN);
                } else {
                   resolve(result);
                }
            }, 1000);
        });
    }
}

And here are the tests that the promise needs to meet:

describe( "Calculator.calculate", function(){
  let calculator;

  beforeEach( function(){
    calculator = new Calculator();
  } );
  
  it( "returns a promise", function( done ){
    const
      callDone = () => done(),
      calculating = calculator.calculate( () => void 0 );
    expect( calculating ).to.be.instanceOf( Promise );
    calculating.then( callDone ).catch( callDone );
  } );
     
  it( "resolves with the result when the calculation succeeds", function( done ){
    const calculating = calculator.calculate( function(){
      expect( this ).to.equal( calculator );
      let result = 0;
      result += this.add( 1, 2 );
      result += this.add( 3, 4 );
      return result;
    } );
    calculating
      .then( function( result ){
        expect( result ).to.equal( 10 );
        done();
      } )
      .catch( () => done() );
  } );
  
  it( "rejects with NaN when the calculation fails", function( done ){
    const calculating = calculator.calculate();
    calculating.catch( function( result ){
      expect( result ).to.be.NaN;
      done();
    } );
  } );
} );

The above calculate function I wrote only passes the first test and none of the other. I fear I'm going about it all wrong. How can I make it work?

Answer 1

Some remarks on your attempt:

• The requirements do not suggest that you need to delay a result using setTimeout .

• There is no need for ...args as parameter list for calculate . It will only get one argument, and it should be a function.

• The result variable is never set to anything else than 0. It would need to be the result by calling the callback function (the argument passed to calculate ).

• resolve should be called with the result as argument.

• reject should be called with NaN as argument

• There is no specification that when the result is NaN , the promise should be rejected. The opposite is true: when the promise rejects (because of an error) it should reject with NaN as reason. The last test in the test sequence, passes no argument to calculate , which would lead to an error while calculate tries to execute an argument that is undefined. And then it should return a rejected promise.

We can avoid calling the Promise constructor by declaring the method as async . Here is an implementation that passes those tests:

    async calculate(f) {
        try {   
            return f.call(this);
        } catch {
            throw NaN;
        }
    }