shard gl jasmine tests

Author: etpinard

.circleci/test.sh

@@ -4,6 +4,7 @@
 set +e
 set +o pipefail
 
+ROOT=$(dirname $0)/..
 EXIT_STATE=0
 MAX_AUTO_RETRY=5
 
@@ -34,7 +35,12 @@ case $1 in
         ;;
 
     jasmine2)
-        retry npm run test-jasmine -- --tags=gl --skip-tags=noCI,flaky
+        SHARDS=($(node $ROOT/tasks/shard_jasmine_tests.js --tag=gl))
+
+        for s in ${SHARDS[@]}; do
+            retry npm run test-jasmine -- "$s" --tags=gl --skip-tags=noCI,flaky
+        done
+
         retry npm run test-jasmine -- --tags=flaky --skip-tags=noCI
         exit $EXIT_STATE
         ;;

tasks/shard_jasmine_tests.js

@@ -0,0 +1,112 @@
+var fs = require('fs');
+var path = require('path');
+
+var falafel = require('falafel');
+var glob = require('glob');
+var minimist = require('minimist');
+
+var constants = require('./util/constants');
+var pathToJasmineTests = constants.pathToJasmineTests;
+
+var argv = minimist(process.argv.slice(2), {
+    string: ['tag', 'limit'],
+    alias: {
+        tag: ['t'],
+        limit: ['l'],
+    },
+    default: {
+        limit: 20
+    }
+});
+
+var tag = argv.tag;
+var limit = argv.limit;
+
+glob(path.join(pathToJasmineTests, '*.js'), function(err, files) {
+    if(err) throw err;
+
+    var file2cnt = {};
+
+    files.forEach(function(file) {
+        var code = fs.readFileSync(file, 'utf-8');
+        var bn = path.basename(file);
+
+        falafel(code, function(node) {
+            if(isTestDescription(node, tag)) {
+                if(file2cnt[bn]) {
+                    file2cnt[bn]++;
+                } else {
+                    file2cnt[bn] = 1;
+                }
+            }
+        });
+    });
+
+    var ranking = Object.keys(file2cnt);
+    var runs = [];
+
+    // if 'it' count in file greater than threshold,
+    // run only this file separately,
+    // don't try to shard within file
+    Object.keys(file2cnt).forEach(function(f) {
+        if(file2cnt[f] > limit) {
+            runs.push(f);
+            ranking.splice(ranking.indexOf(f), 1);
+        }
+    });
+
+    // sort ranking in decreasing order
+    ranking.sort(function(a, b) { return file2cnt[b] - file2cnt[a]; });
+
+    var runi;
+    var cnt;
+
+    function newRun() {
+        var r0 = ranking[0];
+        runi = [r0];
+        cnt = file2cnt[r0];
+        ranking.shift();
+    }
+
+    function concat() {
+        runs.push(runi.join(','));
+    }
+
+    // try to match files with many tests with files not-that-many,
+    // by matching first rank with one or multiple trailing ranks.
+    newRun();
+    while(ranking.length) {
+        var rn = ranking[ranking.length - 1];
+
+        if((cnt + file2cnt[rn]) > limit) {
+            concat();
+            newRun();
+        } else {
+            runi.push(rn);
+            cnt += file2cnt[rn];
+            ranking.pop();
+        }
+    }
+    concat();
+
+    // print result to stdout
+    console.log(runs.join('\n'));
+});
+
+function isTestDescription(node, tag) {
+    var isDescription = (
+        node.type === 'Literal' &&
+        node.parent &&
+        node.parent.type === 'CallExpression' &&
+        node.parent.callee &&
+        node.parent.callee.type === 'Identifier' &&
+        node.parent.callee.name === 'it'
+    );
+
+    if(!tag) return isDescription;
+
+    return (
+        isDescription &&
+        node.source().indexOf('@' + tag) !== -1
+    );
+}