Test Javascript Function's Blocking Behavior

Unit Test are based on single-responsability-principle and isolation (separate the subject under test from it's dependencies).

In this case, you expect your function to run asynchronously but this behaviour is not done by your function, is done by the "setTimeout" function, so I think you must isolate your function from "setTimeout" since it's a dependency you don't want to test, the browser guarantees you it will work.

Then, as we trust "setTimeout" will do the asyncrhonous logic, we can only test our function calls to "setTimeout" and we can do this replacing "window.setTimeout" with another function while we must always restore it after the test is complete.

function replaceSetTimeout() {
    var originalSetTimeout = window.setTimeout;
    var callCount = 0;

    window.setTimeout = function() {
        callCount++;
    };

    window.setTimeout.restore = function() {
        window.setTimeout = originalSetTimeout;
    };

    window.setTimeout.getCallCount = function() {
        return callCount;
    };
}

replaceSetTimeout();
asyncFunction();
assert(setTimeout.getCallCount() === 1);
setTimeout.restore();

I recommend you to use sinon.js as it provides many tools like spies who are functions than will inform you about how many times and with what arguments where called.

var originalSetTimeout = window.setTimeout;
window.setTimeout = sinon.spy();
asyncFunction();

// check called only once
assert(setTimeout.calledOnce);
// check the first argument was asyncFunction
assert(setTimeout.calledWith(asyncFunction));

Sinon also provides fake timers who does the setTimeout substitution but with so much more features, like the .tick(x) method who will simulate "x" milliseconds but in this case I think it doesn't help you.

Update to answer question edit:

1 - Your function executes infinitely so you cannot test it without interrupting it's execution, so you must overwrite "setTimeout" somewhere.

2 - You want your function to execute recursively allowing other code to be executed between iterations? great! but understand than your function can not do this your function only can call setTimeout or setInterval and hope this function work as expected. You should test what your function does.

3 - You want to test from Javascript (a sandboxed environment) than another Javascript code uses and releases the only one execution thread (the same you are using to test). Do you really think this is an easy test?

4 - but the most important one - I don't like white box because it couples the test with the dependency, if you change your dependency or how it's called in the future you will have to change the test. This problem doesn't exist with DOM function, DOM functions will keep the same interface for years, and for now, you have no other way to do what you want than calling one of those two functions, so I don't think in this case "white box testing" is a bad idea.

I told you this because I had the same problem testing a Promise pattern implementation than had to be always asynchronous, even if the promise is already fulfilled, and I've tested it using test-engine asynchronous-test way (using callbacks and stuff) and it was a mess, test failing randomly, so much slow test execution. Then I asked a TDD expert how can test be so hard and he answered than I was not following Single Responsability Principle since I was trying to test my promise implementation AND the setTimeout behaviour.

If you think about it from a Behaviour Driven Testing perspective then 'Does my function block?' is not a useful question. It will definitely block, a better question might be 'does it return in no more than 50ms'.

You could do this with something like :

test( "speed test", function() {
  var start = new Date();
  a();
  ok(new Date() - start < 50, "Passed!" );
});

The issue with this is that if someone does do something silly that makes your function block indefinitely the test won't fail, it will hang.

Because JavaScript is single threaded there is no way around this. If I come along and change your function to :

function a() {
    while(true) {
        console.log("invoked")
    }
}

The test will hang.

You can make breaking things this way harder by refactoring things a little. There are 2 separate things being done. Your chunk of work and the scheduling. Separate these and you'll end up with something like the following functions :

function a() {
    // doWork
    var stopRunning = true;

    return stopRunning;
}

function doAsync(workFunc, scheduleFunc, timeout) {
    if (!workFunc()) {
       scheduleFunc(doAsync, [workFunc, scheduleFunc, timeout], timeout);
    }
}

function schedule(func, args, timeout) {
    setTimeout(function() {func.apply(window, args);}, timeout);
}

Now you're free to test everything in isolation. You can supply a mock workFunc and scheduleFunc to a test for doAsync to verify it behaves as expected and you can test your function a() without worrying about how it is scheduled.

It's still possible for a dunce programmer to put an infinite loop into the function a(), but because they don't have to consider how to run further units of work it should be less likely.

To test or prove an infinitely executing execution path will never block is next to impossible, so you have to split your problem up into parts.

Your path is basically foo(foo(foo(foo(...etc...)))), nevermind that SetTimeout actually removes recursion. So all you have to do is test or prove that your foo does not block (I tell you now that testing will be "a bit" easier than proving, more below)

So, does function foo block?

Talking a bit maths, if you want to know whether f(f(...f(x)...)) always has a value, you actually only have to prove that f(x) always has a value for any x that f can return. It does not matter how many recursions you have, if you can make sure their return values are fine.

What that means for your foo is that you only have to prove that foo does not block for any possible input value. Keep in mind that in this case, all global variables and closures are input values too. This means you have to sanity-check every single value you are using on every call.

To test, of course you will have to replace SetTimeout, but that is trivial, and if you replace it with an empty function (function(){}) it is easy to prove that this function does not block or otherwise alter your execution. You will then

Making things easier

Taking in what I wrote above, this also means that you would have to make sure no global function or variable that you are ever using will ever be changed to a point that your function breaks to a point it breaks. This actually is quite hard, but you can still make things easier for you by making sure you always use the same functions and values and that other functions can not touch them by using closures.

function foo(n, setTimeout)
{
   var x = global_var;
   // sanity check n here
   function f()
   {
      setTimeout(f, n)
   }
   return f();
}

• This way, you only have to test those values on the first execution. It's nice to be able to assume Math.Pi is actually Pi and not a string value containing "noodles". Really nice.
• Do not use global mutable objects

• Call those you can not circumvent using setTimeout to ensure they can not block

  • If you need return values, things will get really tricky, but possible, consider this:

    function() {
      var x = 0;
      setTimeout(function(){x = insecure();}, 1); 
    }
    

    All you have to do is

    • Use x next iteration
    • Sanity check value of x first!

• Does SetTimeout block?

  Of course this depends on whether setTimeout blocks. This is quite hard to prove, but a bit easier to test. You can't actually prove it since it's implementation is up to the interpreter.

  Personally I would assume that setTimeout behaves like an empty function when it's return value is discarded.

Performing this asynchronous testing is actually possible in QUnit but is handled better in another JavaScript testing framework, Jasmine JS. I'll provide examples in both.

In QUnit you need to first call the stop() function to signal that the test is expected to run asynchronously, you should then call setTimeout with a function that includes your expectations as well as a call to the start() function to complete the block. Here's an example:

test( "a test", function() {
    stop();
    asyncOp();
    setTimeout(function() {
        equals( asyncOp.result, "someExpectedValue" );
        start();
    }, 150 );
});

Edit: Apparently there's also a whole asyncTest construct that you can use that simplifies this process. Take a look: http://api.qunitjs.com/asyncTest/

In Jasmine (http://pivotal.github.com/jasmine/), a Behavior Driven Development (BDD) testing framework, there are built-in methods for writing asynchronous tests. Here's an example of an asynchronous test in Jasmine:

describe('Some module', function() {

    it('should run asynchronously', function() {
        var isDone = false;
        runs(function() {
            // The first call to runs should trigger some async operation
            // that has a side-effect that can be tested for. In this case,
            // lets say that the doSomethingAsyncWithCallback function
            // does something asynchronously and then calls the passed callback
            doSomethingAsyncWithCallback(function() { isDone = true; });
        });

        waitsFor(function() {
            // The call to waits for is a polling function that will get called
            // periodically until either a condition is met (the function should return
            // a boolean testing for this condition) or the timeout expires.
            // The optional text is what error to display if the test fails.
            return isDone === true;
        }, "Should set isDone to true", 500);

        runs(function() {
            // The second call to runs should contain any assertions you need to make
            // after the async call is complete.
            expect(isDone).toBe(true);
        });
    });
});

Edit: Also, Jasmine has several built-in methods of faking out the setTimeout and setInterval functions of the browser without hosing any other tests in your suite that may depend on that. I would take a look at using those rather than manually overriding the setTimeout/setInterval functions.

Basically, JavaScript is single-threaded, so it will block the main thread. But :

• I assume you're using setTimesout to schedule your function, so it won't be noticeable to the user if calls to that function don't take too much time (say, less than 200 or 300ms).

• If you're doing DOM manipulation during that function (including Canvas or WebGL), then you're screwed. But if not, you can look into Web Workers, which can spawn separate threads that are guaranteed not to block the UI.

But anyway, JavaScript and the main loop, that's a tricky issue that's been bugging me a lot these past months, so you're not alone!

As soon as your function returns (after having set the timeout for it's next run), javascript will look at the next thing that requires running and run that.

As far as I can tell, the 'main thread' in javascript is just a loop that is responding to events (such as onload for a script tag, which runs the contents of that tag).

Based on the above two conditions, the calling thread is always going to run to completion despite any setTimeouts, and those timeouts will begin after the calling thread has nothing left to run.

The way I tested this was to run the following function right after the call to a()

function looper(name,duration) {
    var start = (new Date()).getTime();
    var elapsed = 0;
    while (elapsed < duration) {
        elapsed = (new Date()).getTime() - start;
        console.log(name + ": " + elapsed);
    }        
}

Duration should be set to some period of time longer than the setTimeout duration in a(). The expected output would be the output of 'looper', followed by the output of repeated calls to a().

The next thing to test would be whether other script tags are able to run while a() and its child calls are executing.

You can do this like so:

<script>
    a(); 
</script>
<script>
    looper('delay',500); // ie; less than the 1000 timeout in a();
</script>
<script>
    console.log('OK');
</script>

You would expect 'OK' to appear in the log despite the fact that a() and its children are still executing. You can also test variations of this, such as window.onload(), etc.

Finally, you'd want to ensure that other timer events work fine as well. Simply delaying 2 calls by half a second and checking that they interleave should show that works fine:

function b()
{
    console.log("invoked b")
    setTimeout(b, 1000);
}

a();
looper('wait',500);
b();

Should produce output like

invoked
invoked b
invoked
invoked b
invoked
invoked b

Hope that's what you were looking for!

EDIT in case you need some technical details on how to do it in Qunit:

If Qunit can't capture console.log output (i'm not sure), just push those strings into an array or a string and check that after it's run. You could override console.log in the test module() setup and restore it at teardown. I'm not sure how Qunit works but 'this' might have to be removed and globals used to store the old_console_log and test_output

// in the setup
this.old_console_log = console.log;
this.test_output = [];
var self = this;
console.log = function(text) { self.test_output.push(text); }

// in the teardown
console.log = this.old_console_log;

Finally, you can utilize stop() and start() so that Qunit knows to wait for all the events in the test to finish running.

stop();
kickoff_async_test();
setTimeout(function(){
    // assertions
    start();
    },<expected duration of run>);