“ it”块执行多次，直到在Jasmine 2.0中调用“ done”为止

Question

I am creating a test case in Jasmine 2.0

    describe("TestCase", function(){

        var originalTimeout=0;

        beforeEach(function(){
            originalTimeout=jasmine.DEFAULT_TIMEOUT_INTERVAL;
            jasmine.DEFAULT_TIMEOUT_INTERVAL=10000;
        });

        afterEach(function(){
            jasmine.DEFAULT_TIMEOUT_INTERVAL=originalTimeout;
        });

        it("check timeout", function(done){
            var startTime=new Date().getTime() / 1000; //line 15
            setTimeout(function(){
                var currentTime=new Date().getTime() / 1000;
                expect(currentTime).toBeGreaterThan(startTime);
                done();
            },5000);
        });
   });

While debugging it I noticed that if we keep a breakpoint at line 15, it gets hit again and again until done in the setTimeout is called. Is there any explaination for this behavior? This behavior leads to execution of same test again and again.

Answer 1

Ok, I've had a good look through the Jasmine source and I see that a lot of work has been done between 1.x -- 2.x -- master in this area.

However, I cannot find a loop where the same it gets called again and again waiting for the done() to be called.

Here is the relevant code from 2.0 :

  if (fn.length > 0) {
    attempt(function() { fn.call(self, function() {  self.run(fns, index + 1) }) });
  } else {
    attempt(function() { fn.call(self); });
    self.run(fns, index + 1);
  } 

  function attempt(fn) {
    try {
      fn();
    } catch (e) {
      self.onException(e);
      if (!self.catchingExceptions()) {
        //TODO: set a var when we catch an exception and
        //use a finally block to close the loop in a nice way..
        throw e;
      }
    }
  }

You can see that the above code checks to see if there is a done argument fn.length > 0 and then creates the done as the call to execute the next test case.

This is similar to the code on master (however, master has changed a lot):

    for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
      var queueableFn = queueableFns[iterativeIndex];
      if (queueableFn.fn.length > 0) {
        attemptAsync(queueableFn);
        return;
      } else {
        attemptSync(queueableFn);
      }
    }

    function attemptAsync(queueableFn) {
      var clearTimeout = function () {
          Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]);
        },
        next = once(function () {
          clearTimeout(timeoutId);
          self.run(queueableFns, iterativeIndex + 1);
        }),
        timeoutId;

      next.fail = function() {
        self.fail.apply(null, arguments);
        next();
      };

      if (queueableFn.timeout) {
        timeoutId = Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [function() {
          var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
          onException(error, queueableFn);
          next();
        }, queueableFn.timeout()]]);
      }

      try {
        queueableFn.fn.call(self.userContext, next);
      } catch (e) {
        handleException(e, queueableFn);
        next();
      }
    }

This is largely similar except for a couple changes. First, code adds another setTimeout around the async call (and adds a timeout error message). Second, the call to the next test case is also wrapped in a call to once :

  function once(fn) {
    var called = false;
    return function() {
      if (!called) {
        called = true;
        fn();
      }
    };
  }

The once function makes sure that the test is only called once. Which makes me thing that there was a bug in 2.0 (that I don't see) whereby the test was being called again and again.

Although inconclusive, this might give you some ideas. It may be an IDE issue instead of a Jasmine issue.

Anyway, I hope this helps.