Non cached files are not preprocessed

I noticed this because I’m using rollup (+ babel) to transpile ES2015 tests into ES5. With the ‘default’ configuration, tests are transpiled but then cached, so when I change the source, the cached version is served.

Expected behavior

Using

karma.conf.js

module.exports = function(config) {
    config.set({
        files: [
            { pattern: 'test/*.js', nocache: true }
        ],
        preprocessors: {
            'test/**/*.js': ['rollup']
        }

I expect test files to run through the preprocessor and not being cached.

Actual behavior

Files are not cached, but are not even processed

Enviroment Details

• Karma version (output of karma --version): 1.1.1

The logic is defined around these lines and introduced in this commit.

Clearly the intent of the committer (@nmalaguti) was to avoid preprocessing, but I feel like nocache is now serving two purposes

1. don’t cache the file
2. don’t preprocess

In my use case I’d like to have use (1.) without (2.), best of both worlds would be to have

{ pattern: '*.js', included: Boolean, watched: Boolean, served: Boolean, nocache: Boolean, preprocess: Boolean }

[fvclaus]

I would expect nocache to run the preprocessor on a file everytime it is served. That would be equivalent to serving “static” files from disk.

This also prevents css preprocessors that include other files from working properly. If an included file is changed, karma does not pick up on these changes and serves the old version. I think this issue should be addressed in one of two ways:

• Add documentation that nocache is incompatible with preprocessors that do not write to disk. The change mentioned by @johnjbarton only works, if the preprocessor writes the file to the disk, because serveFile will try to read it from the disk.
• Properly support nocached: true preprocessed files by preprocessing them every time they are served. I dug around the codebase a little and implemented this feature here: https://github.com/fvclaus/karma/commit/ddc74beda2b7cd3b588d02da29d34d523ed9a9d3 It flags files that are preprocessed with file.isPreprocessed = true. If they also have nocache set to true, it preprocesses them with changeFile(..., true) and greps the new version of the file. The code is a little awkward, because changeFile returns all files instead of the changed file and serveFile does not work with files at all. I also had to force doNotCache = false for preprocessed files that have nocache: true with file.doNotCache && !file.isPreprocessed, otherwise serveFile will try to read them from the disk. Let me know if this could be a candidate for a PR and I will be happy to better integrate it into the existing codebase.

[nmalaguti]

@maksimr the way that preprocessing worked at the time (and may still work - I haven’t been working with karma in a while) is that each file was preprocessed once at start or on change and the result was cached in memory. If nocache is enabled, there is nowhere to store the result of preprocessing (unless you write it to disk, which karma doesn’t do), so preprocessing doesn’t make sense. nocache only makes sense for files that either won’t be changing while karma runs, or will be changed by a separate process (e.g. gulp watch) and can be served up as is.

The problem I was solving for with nocache was that I didn’t need potentially thousands of files being watched and cached in memory (e.g. including all of node_modules for some css files) when I knew that I would never be making changes to them and there was no processing to be done.