Think the thing most of us would like to have is a system that allows us to debounce the incoming changes till no further changes have occurred for an x amount of ms.

A perfect example of this is illustrated within RXJS:
http://reactivex.io/documentation/operators/debounce.html

Having an option like that would be very useful.

Stand alone version of debounce:
https://davidwalsh.name/javascript-debounce-function

Which would mean the following function probably would have to be modified:

https://github.com/karma-runner/karma/blob/master/lib/watcher.js#L93

Once i change the bind function to this i have the desired behaviour:

    function bind(func, wait, immediate) {
        var timeout;
        return function(path) {
            var context = this, args = arguments;
            var later = function() {
                timeout = null;
                if (!immediate) func.call(fileList, helper.normalizeWinPath(path));// func.apply(context, args);
            };
            var callNow = immediate && !timeout;
            clearTimeout(timeout);
            timeout = setTimeout(later, wait);
            if (callNow) func.call(fileList, helper.normalizeWinPath(path));
        };
    };

    chokidarWatcher.on('add', bind(fileList.addFile, 1000))
        .on('change', bind(fileList.changeFile, 1000))
        .on('unlink', bind(fileList.removeFile, 1000))

@schippie this is exactly what I'm after.

Sounds good to me. I agree it does make sense to change the option to this behaviour.

I ran into this exact issue - chokidar has a nice option called awaitWriteFinish which solves this problem quite well.

awaitWriteFinish looks useful and may be helpful, but wouldn't solve this problem on it's own probably. I still need to handle the case where multiple files are written in one recompile cycle.

You're right - opened issue #2420 to discuss a different but related issue.

Just a note for future searchers who find this, the second half of making this work for testing ClojureScript files is to disable the caching of any files written by the compiler.

The Google Closure Compiler (GCC) writes files to disk in chunks. By default, Karma will cache the files on disk when serving web requests. However there is a race condition that exists where:

1. GCC writes part of a file. At this point, the file is probably not even syntactically correct.
2. Karma file watcher detects the change
3. Karma caches the partially written file
4. GCC finishes writing the file. The file is now valid JavaScript.
5. autoWatchBatchDelay time passes
6. Karma runs the tests
7. The browser requests the file.
8. Karma serves the partial file to the browser
9. You get a confusing test error like "message": "Uncaught SyntaxError: missing ) after argument list..."

The fix is to update your file watchers to set nocache: true: e.g.

files: [
            ...
            {pattern: root + '/**/*.+(cljs|cljc|clj|js|js.map)', included: false, nocache: true}
        ],