Js promise for calculator

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?

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;
        }
    }