140 lines
4.9 KiB
TypeScript
140 lines
4.9 KiB
TypeScript
/**
|
|
* Copyright Microsoft Corporation. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import path from 'path';
|
|
import { fixturesForCallback } from './fixtures';
|
|
import { Configuration, Test, Suite } from './test';
|
|
import { fixturesUI } from './fixturesUI';
|
|
|
|
export class TestCollector {
|
|
suite: Suite;
|
|
|
|
private _matrix: { [key: string]: string; };
|
|
private _options: any;
|
|
private _grep: RegExp;
|
|
private _hasOnly: boolean;
|
|
|
|
constructor(files: string[], matrix: { [key: string] : string }, options) {
|
|
this._matrix = matrix;
|
|
this._options = options;
|
|
this.suite = new Suite('');
|
|
if (options.grep) {
|
|
const match = options.grep.match(/^\/(.*)\/(g|i|)$|.*/);
|
|
this._grep = new RegExp(match[1] || match[0], match[2]);
|
|
}
|
|
|
|
for (const file of files)
|
|
this._addFile(file);
|
|
|
|
this._hasOnly = this._filterOnly(this.suite);
|
|
}
|
|
|
|
hasOnly() {
|
|
return this._hasOnly;
|
|
}
|
|
|
|
_addFile(file) {
|
|
const suite = new Suite('');
|
|
const revertBabelRequire = fixturesUI(suite, file, this._options.timeout);
|
|
require(file);
|
|
revertBabelRequire();
|
|
suite._renumber();
|
|
|
|
const workerGeneratorConfigurations = new Map();
|
|
|
|
suite.eachTest((test: Test) => {
|
|
// Get all the fixtures that the test needs.
|
|
const fixtures = fixturesForCallback(test.fn);
|
|
|
|
// For generator fixtures, collect all variants of the fixture values
|
|
// to build different workers for them.
|
|
const generatorConfigurations = [];
|
|
for (const name of fixtures) {
|
|
const values = this._matrix[name];
|
|
if (!values)
|
|
continue;
|
|
let state = generatorConfigurations.length ? generatorConfigurations.slice() : [[]];
|
|
generatorConfigurations.length = 0;
|
|
for (const gen of state) {
|
|
for (const value of values)
|
|
generatorConfigurations.push([...gen, { name, value }]);
|
|
}
|
|
}
|
|
|
|
// No generator fixtures for test, include empty set.
|
|
if (!generatorConfigurations.length)
|
|
generatorConfigurations.push([]);
|
|
|
|
for (const configurationObject of generatorConfigurations) {
|
|
// Serialize configuration as readable string, we will use it as a hash.
|
|
const tokens = [];
|
|
for (const { name, value } of configurationObject)
|
|
tokens.push(`${name}=${value}`);
|
|
const configurationString = tokens.join(', ');
|
|
// Allocate worker for this configuration, add test into it.
|
|
if (!workerGeneratorConfigurations.has(configurationString))
|
|
workerGeneratorConfigurations.set(configurationString, { configurationObject, configurationString, tests: new Set() });
|
|
workerGeneratorConfigurations.get(configurationString).tests.add(test);
|
|
}
|
|
});
|
|
|
|
// Clone the suite as many times as there are worker hashes.
|
|
// Only include the tests that requested these generations.
|
|
for (const [hash, {configurationObject, configurationString, tests}] of workerGeneratorConfigurations.entries()) {
|
|
const clone = this._cloneSuite(suite, configurationObject, configurationString, tests);
|
|
this.suite.addSuite(clone);
|
|
clone.title = path.basename(file) + (hash.length ? `::[${hash}]` : '');
|
|
}
|
|
}
|
|
|
|
_cloneSuite(suite: Suite, configurationObject: Configuration, configurationString: string, tests: Set<Test>) {
|
|
const copy = suite.clone();
|
|
copy.only = suite.only;
|
|
copy.configuration = configurationObject;
|
|
for (const entry of suite._entries) {
|
|
if (entry instanceof Suite) {
|
|
copy.addSuite(this._cloneSuite(entry, configurationObject, configurationString, tests));
|
|
} else {
|
|
const test = entry;
|
|
if (!tests.has(test))
|
|
continue;
|
|
if (this._grep && !this._grep.test(test.fullTitle()))
|
|
continue;
|
|
const testCopy = test.clone();
|
|
testCopy.only = test.only;
|
|
testCopy._ordinal = test._ordinal;
|
|
testCopy._configurationObject = configurationObject;
|
|
testCopy._configurationString = configurationString;
|
|
copy.addTest(testCopy);
|
|
}
|
|
}
|
|
return copy;
|
|
}
|
|
|
|
_filterOnly(suite) {
|
|
const onlySuites = suite.suites.filter(child => this._filterOnly(child) || child.only);
|
|
const onlyTests = suite.tests.filter(test => test.only);
|
|
if (onlySuites.length || onlyTests.length) {
|
|
suite.suites = onlySuites;
|
|
suite.tests = onlyTests;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
module.exports = { TestCollector };
|