774 lines
22 KiB
JavaScript
774 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
exports.default = watch;
|
|
|
|
var _ansiEscapes;
|
|
|
|
function _load_ansiEscapes() {
|
|
return (_ansiEscapes = _interopRequireDefault(require('ansi-escapes')));
|
|
}
|
|
|
|
var _chalk;
|
|
|
|
function _load_chalk() {
|
|
return (_chalk = _interopRequireDefault(require('chalk')));
|
|
}
|
|
|
|
var _getChangedFilesPromise;
|
|
|
|
function _load_getChangedFilesPromise() {
|
|
return (_getChangedFilesPromise = _interopRequireDefault(
|
|
require('./getChangedFilesPromise')
|
|
));
|
|
}
|
|
|
|
var _exit;
|
|
|
|
function _load_exit() {
|
|
return (_exit = _interopRequireDefault(require('exit')));
|
|
}
|
|
|
|
var _jestHasteMap;
|
|
|
|
function _load_jestHasteMap() {
|
|
return (_jestHasteMap = _interopRequireDefault(require('jest-haste-map')));
|
|
}
|
|
|
|
var _is_valid_path;
|
|
|
|
function _load_is_valid_path() {
|
|
return (_is_valid_path = _interopRequireDefault(
|
|
require('./lib/is_valid_path')
|
|
));
|
|
}
|
|
|
|
var _jestUtil;
|
|
|
|
function _load_jestUtil() {
|
|
return (_jestUtil = require('jest-util'));
|
|
}
|
|
|
|
var _preRunMessage;
|
|
|
|
function _load_preRunMessage() {
|
|
return (_preRunMessage = require('./preRunMessage'));
|
|
}
|
|
|
|
var _create_context;
|
|
|
|
function _load_create_context() {
|
|
return (_create_context = _interopRequireDefault(
|
|
require('./lib/create_context')
|
|
));
|
|
}
|
|
|
|
var _runJest;
|
|
|
|
function _load_runJest() {
|
|
return (_runJest = _interopRequireDefault(require('./runJest')));
|
|
}
|
|
|
|
var _update_global_config;
|
|
|
|
function _load_update_global_config() {
|
|
return (_update_global_config = _interopRequireDefault(
|
|
require('./lib/update_global_config')
|
|
));
|
|
}
|
|
|
|
var _SearchSource;
|
|
|
|
function _load_SearchSource() {
|
|
return (_SearchSource = _interopRequireDefault(require('./SearchSource')));
|
|
}
|
|
|
|
var _TestWatcher;
|
|
|
|
function _load_TestWatcher() {
|
|
return (_TestWatcher = _interopRequireDefault(require('./TestWatcher')));
|
|
}
|
|
|
|
var _FailedTestsCache;
|
|
|
|
function _load_FailedTestsCache() {
|
|
return (_FailedTestsCache = _interopRequireDefault(
|
|
require('./FailedTestsCache')
|
|
));
|
|
}
|
|
|
|
var _constants;
|
|
|
|
function _load_constants() {
|
|
return (_constants = require('./constants'));
|
|
}
|
|
|
|
var _jestWatcher;
|
|
|
|
function _load_jestWatcher() {
|
|
return (_jestWatcher = require('jest-watcher'));
|
|
}
|
|
|
|
var _test_path_pattern;
|
|
|
|
function _load_test_path_pattern() {
|
|
return (_test_path_pattern = _interopRequireDefault(
|
|
require('./plugins/test_path_pattern')
|
|
));
|
|
}
|
|
|
|
var _test_name_pattern;
|
|
|
|
function _load_test_name_pattern() {
|
|
return (_test_name_pattern = _interopRequireDefault(
|
|
require('./plugins/test_name_pattern')
|
|
));
|
|
}
|
|
|
|
var _update_snapshots;
|
|
|
|
function _load_update_snapshots() {
|
|
return (_update_snapshots = _interopRequireDefault(
|
|
require('./plugins/update_snapshots')
|
|
));
|
|
}
|
|
|
|
var _update_snapshots_interactive;
|
|
|
|
function _load_update_snapshots_interactive() {
|
|
return (_update_snapshots_interactive = _interopRequireDefault(
|
|
require('./plugins/update_snapshots_interactive')
|
|
));
|
|
}
|
|
|
|
var _quit;
|
|
|
|
function _load_quit() {
|
|
return (_quit = _interopRequireDefault(require('./plugins/quit')));
|
|
}
|
|
|
|
var _watch_plugins_helpers;
|
|
|
|
function _load_watch_plugins_helpers() {
|
|
return (_watch_plugins_helpers = require('./lib/watch_plugins_helpers'));
|
|
}
|
|
|
|
var _jestValidate;
|
|
|
|
function _load_jestValidate() {
|
|
return (_jestValidate = require('jest-validate'));
|
|
}
|
|
|
|
var _active_filters_message;
|
|
|
|
function _load_active_filters_message() {
|
|
return (_active_filters_message = _interopRequireDefault(
|
|
require('./lib/active_filters_message')
|
|
));
|
|
}
|
|
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {default: obj};
|
|
}
|
|
|
|
function _toConsumableArray(arr) {
|
|
if (Array.isArray(arr)) {
|
|
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++)
|
|
arr2[i] = arr[i];
|
|
return arr2;
|
|
} else {
|
|
return Array.from(arr);
|
|
}
|
|
}
|
|
/**
|
|
* Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
*
|
|
*/
|
|
|
|
let hasExitListener = false;
|
|
|
|
const INTERNAL_PLUGINS = [
|
|
(_test_path_pattern || _load_test_path_pattern()).default,
|
|
(_test_name_pattern || _load_test_name_pattern()).default,
|
|
(_update_snapshots || _load_update_snapshots()).default,
|
|
(_update_snapshots_interactive || _load_update_snapshots_interactive())
|
|
.default,
|
|
(_quit || _load_quit()).default
|
|
];
|
|
|
|
const RESERVED_KEY_PLUGINS = new Map([
|
|
[
|
|
(_update_snapshots || _load_update_snapshots()).default,
|
|
{forbiddenOverwriteMessage: 'updating snapshots', key: 'u'}
|
|
],
|
|
[
|
|
(_update_snapshots_interactive || _load_update_snapshots_interactive())
|
|
.default,
|
|
{forbiddenOverwriteMessage: 'updating snapshots interactively', key: 'i'}
|
|
],
|
|
[
|
|
(_quit || _load_quit()).default,
|
|
{forbiddenOverwriteMessage: 'quitting watch mode'}
|
|
]
|
|
]);
|
|
|
|
function watch(initialGlobalConfig, contexts, outputStream, hasteMapInstances) {
|
|
let stdin =
|
|
arguments.length > 4 && arguments[4] !== undefined
|
|
? arguments[4]
|
|
: process.stdin;
|
|
let hooks =
|
|
arguments.length > 5 && arguments[5] !== undefined
|
|
? arguments[5]
|
|
: new (_jestWatcher || _load_jestWatcher()).JestHook();
|
|
|
|
// `globalConfig` will be constantly updated and reassigned as a result of
|
|
// watch mode interactions.
|
|
let globalConfig = initialGlobalConfig;
|
|
let activePlugin;
|
|
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
mode: globalConfig.watch ? 'watch' : 'watchAll',
|
|
passWithNoTests: true
|
|
}
|
|
);
|
|
|
|
const updateConfigAndRun = function() {
|
|
var _ref =
|
|
arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
let bail = _ref.bail,
|
|
changedSince = _ref.changedSince,
|
|
collectCoverage = _ref.collectCoverage,
|
|
collectCoverageFrom = _ref.collectCoverageFrom,
|
|
collectCoverageOnlyFrom = _ref.collectCoverageOnlyFrom,
|
|
coverageDirectory = _ref.coverageDirectory,
|
|
coverageReporters = _ref.coverageReporters,
|
|
mode = _ref.mode,
|
|
notify = _ref.notify,
|
|
notifyMode = _ref.notifyMode,
|
|
onlyFailures = _ref.onlyFailures,
|
|
reporters = _ref.reporters,
|
|
testNamePattern = _ref.testNamePattern,
|
|
testPathPattern = _ref.testPathPattern,
|
|
updateSnapshot = _ref.updateSnapshot,
|
|
verbose = _ref.verbose;
|
|
|
|
const previousUpdateSnapshot = globalConfig.updateSnapshot;
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
bail: bail,
|
|
changedSince: changedSince,
|
|
collectCoverage: collectCoverage,
|
|
collectCoverageFrom: collectCoverageFrom,
|
|
collectCoverageOnlyFrom: collectCoverageOnlyFrom,
|
|
coverageDirectory: coverageDirectory,
|
|
coverageReporters: coverageReporters,
|
|
mode: mode,
|
|
notify: notify,
|
|
notifyMode: notifyMode,
|
|
onlyFailures: onlyFailures,
|
|
reporters: reporters,
|
|
testNamePattern: testNamePattern,
|
|
testPathPattern: testPathPattern,
|
|
updateSnapshot: updateSnapshot,
|
|
verbose: verbose
|
|
}
|
|
);
|
|
|
|
startRun(globalConfig);
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
// updateSnapshot is not sticky after a run.
|
|
updateSnapshot:
|
|
previousUpdateSnapshot === 'all' ? 'none' : previousUpdateSnapshot
|
|
}
|
|
);
|
|
};
|
|
|
|
const watchPlugins = INTERNAL_PLUGINS.map(
|
|
InternalPlugin => new InternalPlugin({stdin: stdin, stdout: outputStream})
|
|
);
|
|
watchPlugins.forEach(plugin => {
|
|
const hookSubscriber = hooks.getSubscriber();
|
|
if (plugin.apply) {
|
|
plugin.apply(hookSubscriber);
|
|
}
|
|
});
|
|
|
|
if (globalConfig.watchPlugins != null) {
|
|
const watchPluginKeys = new Map();
|
|
for (const plugin of watchPlugins) {
|
|
const reservedInfo = RESERVED_KEY_PLUGINS.get(plugin.constructor) || {};
|
|
const key = reservedInfo.key || getPluginKey(plugin, globalConfig);
|
|
if (!key) {
|
|
continue;
|
|
}
|
|
const forbiddenOverwriteMessage = reservedInfo.forbiddenOverwriteMessage;
|
|
|
|
watchPluginKeys.set(key, {
|
|
forbiddenOverwriteMessage: forbiddenOverwriteMessage,
|
|
overwritable: forbiddenOverwriteMessage == null,
|
|
plugin: plugin
|
|
});
|
|
}
|
|
|
|
for (const pluginWithConfig of globalConfig.watchPlugins) {
|
|
// $FlowFixMe dynamic require
|
|
const ThirdPartyPlugin = require(pluginWithConfig.path);
|
|
const plugin = new ThirdPartyPlugin({
|
|
config: pluginWithConfig.config,
|
|
stdin: stdin,
|
|
stdout: outputStream
|
|
});
|
|
checkForConflicts(watchPluginKeys, plugin, globalConfig);
|
|
|
|
const hookSubscriber = hooks.getSubscriber();
|
|
if (plugin.apply) {
|
|
plugin.apply(hookSubscriber);
|
|
}
|
|
watchPlugins.push(plugin);
|
|
}
|
|
}
|
|
|
|
const failedTestsCache = new (
|
|
_FailedTestsCache || _load_FailedTestsCache()
|
|
).default();
|
|
let searchSources = contexts.map(context => ({
|
|
context: context,
|
|
searchSource: new (_SearchSource || _load_SearchSource()).default(context)
|
|
}));
|
|
let isRunning = false;
|
|
let testWatcher;
|
|
let shouldDisplayWatchUsage = true;
|
|
let isWatchUsageDisplayed = false;
|
|
|
|
const emitFileChange = () => {
|
|
if (hooks.isUsed('onFileChange')) {
|
|
const projects = searchSources.map(_ref2 => {
|
|
let context = _ref2.context,
|
|
searchSource = _ref2.searchSource;
|
|
return {
|
|
config: context.config,
|
|
testPaths: searchSource.findMatchingTests('').tests.map(t => t.path)
|
|
};
|
|
});
|
|
hooks.getEmitter().onFileChange({projects: projects});
|
|
}
|
|
};
|
|
|
|
emitFileChange();
|
|
|
|
hasteMapInstances.forEach((hasteMapInstance, index) => {
|
|
hasteMapInstance.on('change', _ref3 => {
|
|
let eventsQueue = _ref3.eventsQueue,
|
|
hasteFS = _ref3.hasteFS,
|
|
moduleMap = _ref3.moduleMap;
|
|
|
|
const validPaths = eventsQueue.filter(_ref4 => {
|
|
let filePath = _ref4.filePath;
|
|
return (0, (_is_valid_path || _load_is_valid_path()).default)(
|
|
globalConfig,
|
|
contexts[index].config,
|
|
filePath
|
|
);
|
|
});
|
|
|
|
if (validPaths.length) {
|
|
const context = (contexts[index] = (0,
|
|
(_create_context || _load_create_context()).default)(
|
|
contexts[index].config,
|
|
{
|
|
hasteFS: hasteFS,
|
|
moduleMap: moduleMap
|
|
}
|
|
));
|
|
|
|
activePlugin = null;
|
|
|
|
searchSources = searchSources.slice();
|
|
searchSources[index] = {
|
|
context: context,
|
|
searchSource: new (_SearchSource || _load_SearchSource()).default(
|
|
context
|
|
)
|
|
};
|
|
emitFileChange();
|
|
startRun(globalConfig);
|
|
}
|
|
});
|
|
});
|
|
|
|
if (!hasExitListener) {
|
|
hasExitListener = true;
|
|
process.on('exit', () => {
|
|
if (activePlugin) {
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.cursorDown()
|
|
);
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.eraseDown
|
|
);
|
|
}
|
|
});
|
|
}
|
|
|
|
const startRun = globalConfig => {
|
|
if (isRunning) {
|
|
return null;
|
|
}
|
|
|
|
testWatcher = new (_TestWatcher || _load_TestWatcher()).default({
|
|
isWatchMode: true
|
|
});
|
|
(_jestUtil || _load_jestUtil()).isInteractive &&
|
|
outputStream.write((_constants || _load_constants()).CLEAR);
|
|
(0, (_preRunMessage || _load_preRunMessage()).print)(outputStream);
|
|
isRunning = true;
|
|
const configs = contexts.map(context => context.config);
|
|
const changedFilesPromise = (0,
|
|
(_getChangedFilesPromise || _load_getChangedFilesPromise()).default)(
|
|
globalConfig,
|
|
configs
|
|
);
|
|
return (0, (_runJest || _load_runJest()).default)({
|
|
changedFilesPromise: changedFilesPromise,
|
|
contexts: contexts,
|
|
failedTestsCache: failedTestsCache,
|
|
globalConfig: globalConfig,
|
|
jestHooks: hooks.getEmitter(),
|
|
onComplete: results => {
|
|
isRunning = false;
|
|
hooks.getEmitter().onTestRunComplete(results);
|
|
|
|
// Create a new testWatcher instance so that re-runs won't be blocked.
|
|
// The old instance that was passed to Jest will still be interrupted
|
|
// and prevent test runs from the previous run.
|
|
testWatcher = new (_TestWatcher || _load_TestWatcher()).default({
|
|
isWatchMode: true
|
|
});
|
|
|
|
// Do not show any Watch Usage related stuff when running in a
|
|
// non-interactive environment
|
|
if ((_jestUtil || _load_jestUtil()).isInteractive) {
|
|
if (shouldDisplayWatchUsage) {
|
|
outputStream.write(usage(globalConfig, watchPlugins));
|
|
shouldDisplayWatchUsage = false; // hide Watch Usage after first run
|
|
isWatchUsageDisplayed = true;
|
|
} else {
|
|
outputStream.write(showToggleUsagePrompt());
|
|
shouldDisplayWatchUsage = false;
|
|
isWatchUsageDisplayed = false;
|
|
}
|
|
} else {
|
|
outputStream.write('\n');
|
|
}
|
|
failedTestsCache.setTestResults(results.testResults);
|
|
},
|
|
outputStream: outputStream,
|
|
startRun: startRun,
|
|
testWatcher: testWatcher
|
|
}).catch(error =>
|
|
// Errors thrown inside `runJest`, e.g. by resolvers, are caught here for
|
|
// continuous watch mode execution. We need to reprint them to the
|
|
// terminal and give just a little bit of extra space so they fit below
|
|
// `preRunMessagePrint` message nicely.
|
|
console.error('\n\n' + (_chalk || _load_chalk()).default.red(error))
|
|
);
|
|
};
|
|
|
|
const onKeypress = key => {
|
|
if (
|
|
key === (_jestWatcher || _load_jestWatcher()).KEYS.CONTROL_C ||
|
|
key === (_jestWatcher || _load_jestWatcher()).KEYS.CONTROL_D
|
|
) {
|
|
if (typeof stdin.setRawMode === 'function') {
|
|
stdin.setRawMode(false);
|
|
}
|
|
outputStream.write('\n');
|
|
(0, (_exit || _load_exit()).default)(0);
|
|
return;
|
|
}
|
|
|
|
if (activePlugin != null && activePlugin.onKey) {
|
|
// if a plugin is activate, Jest should let it handle keystrokes, so ignore
|
|
// them here
|
|
activePlugin.onKey(key);
|
|
return;
|
|
}
|
|
|
|
// Abort test run
|
|
const pluginKeys = (0,
|
|
(_watch_plugins_helpers || _load_watch_plugins_helpers())
|
|
.getSortedUsageRows)(watchPlugins, globalConfig).map(usage =>
|
|
Number(usage.key).toString(16)
|
|
);
|
|
if (
|
|
isRunning &&
|
|
testWatcher &&
|
|
['q', (_jestWatcher || _load_jestWatcher()).KEYS.ENTER, 'a', 'o', 'f']
|
|
.concat(pluginKeys)
|
|
.includes(key)
|
|
) {
|
|
testWatcher.setState({interrupted: true});
|
|
return;
|
|
}
|
|
|
|
const matchingWatchPlugin = (0,
|
|
(_watch_plugins_helpers || _load_watch_plugins_helpers())
|
|
.filterInteractivePlugins)(watchPlugins, globalConfig).find(
|
|
plugin => getPluginKey(plugin, globalConfig) === key
|
|
);
|
|
|
|
if (matchingWatchPlugin != null) {
|
|
// "activate" the plugin, which has jest ignore keystrokes so the plugin
|
|
// can handle them
|
|
activePlugin = matchingWatchPlugin;
|
|
if (activePlugin.run) {
|
|
activePlugin.run(globalConfig, updateConfigAndRun).then(
|
|
shouldRerun => {
|
|
activePlugin = null;
|
|
if (shouldRerun) {
|
|
updateConfigAndRun();
|
|
}
|
|
},
|
|
() => {
|
|
activePlugin = null;
|
|
onCancelPatternPrompt();
|
|
}
|
|
);
|
|
} else {
|
|
activePlugin = null;
|
|
}
|
|
}
|
|
|
|
switch (key) {
|
|
case (_jestWatcher || _load_jestWatcher()).KEYS.ENTER:
|
|
startRun(globalConfig);
|
|
break;
|
|
case 'a':
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
mode: 'watchAll',
|
|
testNamePattern: '',
|
|
testPathPattern: ''
|
|
}
|
|
);
|
|
startRun(globalConfig);
|
|
break;
|
|
case 'c':
|
|
updateConfigAndRun({
|
|
mode: 'watch',
|
|
testNamePattern: '',
|
|
testPathPattern: ''
|
|
});
|
|
break;
|
|
case 'f':
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
onlyFailures: !globalConfig.onlyFailures
|
|
}
|
|
);
|
|
startRun(globalConfig);
|
|
break;
|
|
case 'o':
|
|
globalConfig = (0,
|
|
(_update_global_config || _load_update_global_config()).default)(
|
|
globalConfig,
|
|
{
|
|
mode: 'watch',
|
|
testNamePattern: '',
|
|
testPathPattern: ''
|
|
}
|
|
);
|
|
startRun(globalConfig);
|
|
break;
|
|
case '?':
|
|
break;
|
|
case 'w':
|
|
if (!shouldDisplayWatchUsage && !isWatchUsageDisplayed) {
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.cursorUp()
|
|
);
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.eraseDown
|
|
);
|
|
outputStream.write(usage(globalConfig, watchPlugins));
|
|
isWatchUsageDisplayed = true;
|
|
shouldDisplayWatchUsage = false;
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
const onCancelPatternPrompt = () => {
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.cursorHide
|
|
);
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.clearScreen
|
|
);
|
|
outputStream.write(usage(globalConfig, watchPlugins));
|
|
outputStream.write(
|
|
(_ansiEscapes || _load_ansiEscapes()).default.cursorShow
|
|
);
|
|
};
|
|
|
|
if (typeof stdin.setRawMode === 'function') {
|
|
stdin.setRawMode(true);
|
|
stdin.resume();
|
|
stdin.setEncoding('utf8');
|
|
stdin.on('data', onKeypress);
|
|
}
|
|
|
|
startRun(globalConfig);
|
|
return Promise.resolve();
|
|
}
|
|
|
|
const checkForConflicts = (watchPluginKeys, plugin, globalConfig) => {
|
|
const key = getPluginKey(plugin, globalConfig);
|
|
if (!key) {
|
|
return;
|
|
}
|
|
|
|
const conflictor = watchPluginKeys.get(key);
|
|
if (!conflictor || conflictor.overwritable) {
|
|
watchPluginKeys.set(key, {
|
|
overwritable: false,
|
|
plugin: plugin
|
|
});
|
|
return;
|
|
}
|
|
|
|
let error;
|
|
if (conflictor.forbiddenOverwriteMessage) {
|
|
error = `
|
|
Watch plugin ${(_chalk || _load_chalk()).default.bold.red(
|
|
getPluginIdentifier(plugin)
|
|
)} attempted to register key ${(_chalk || _load_chalk()).default.bold.red(
|
|
`<${key}>`
|
|
)},
|
|
that is reserved internally for ${(_chalk || _load_chalk()).default.bold.red(
|
|
conflictor.forbiddenOverwriteMessage
|
|
)}.
|
|
Please change the configuration key for this plugin.`.trim();
|
|
} else {
|
|
const plugins = [conflictor.plugin, plugin]
|
|
.map(p =>
|
|
(_chalk || _load_chalk()).default.bold.red(getPluginIdentifier(p))
|
|
)
|
|
.join(' and ');
|
|
error = `
|
|
Watch plugins ${plugins} both attempted to register key ${(
|
|
_chalk || _load_chalk()
|
|
).default.bold.red(`<${key}>`)}.
|
|
Please change the key configuration for one of the conflicting plugins to avoid overlap.`.trim();
|
|
}
|
|
|
|
throw new (_jestValidate || _load_jestValidate()).ValidationError(
|
|
'Watch plugin configuration error',
|
|
error
|
|
);
|
|
};
|
|
|
|
const getPluginIdentifier = plugin =>
|
|
// This breaks as `displayName` is not defined as a static, but since
|
|
// WatchPlugin is an interface, and it is my understanding interface
|
|
// static fields are not definable anymore, no idea how to circumvent
|
|
// this :-(
|
|
// $FlowFixMe: leave `displayName` be.
|
|
plugin.constructor.displayName || plugin.constructor.name;
|
|
|
|
const getPluginKey = (plugin, globalConfig) => {
|
|
if (typeof plugin.getUsageInfo === 'function') {
|
|
return (plugin.getUsageInfo(globalConfig) || {}).key;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
const usage = function(globalConfig, watchPlugins) {
|
|
let delimiter =
|
|
arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '\n';
|
|
|
|
const messages = [
|
|
(0, (_active_filters_message || _load_active_filters_message()).default)(
|
|
globalConfig
|
|
),
|
|
globalConfig.testPathPattern || globalConfig.testNamePattern
|
|
? (_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'c' +
|
|
(_chalk || _load_chalk()).default.dim(' to clear filters.')
|
|
: null,
|
|
'\n' + (_chalk || _load_chalk()).default.bold('Watch Usage'),
|
|
globalConfig.watch
|
|
? (_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'a' +
|
|
(_chalk || _load_chalk()).default.dim(' to run all tests.')
|
|
: null,
|
|
globalConfig.onlyFailures
|
|
? (_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'f' +
|
|
(_chalk || _load_chalk()).default.dim(
|
|
' to quit "only failed tests" mode.'
|
|
)
|
|
: (_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'f' +
|
|
(_chalk || _load_chalk()).default.dim(' to run only failed tests.'),
|
|
(globalConfig.watchAll ||
|
|
globalConfig.testPathPattern ||
|
|
globalConfig.testNamePattern) &&
|
|
!globalConfig.noSCM
|
|
? (_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'o' +
|
|
(_chalk || _load_chalk()).default.dim(
|
|
' to only run tests related to changed files.'
|
|
)
|
|
: null
|
|
].concat(
|
|
_toConsumableArray(
|
|
(0,
|
|
(_watch_plugins_helpers || _load_watch_plugins_helpers())
|
|
.getSortedUsageRows)(watchPlugins, globalConfig).map(
|
|
plugin =>
|
|
(_chalk || _load_chalk()).default.dim(' \u203A Press') +
|
|
' ' +
|
|
plugin.key +
|
|
' ' +
|
|
(_chalk || _load_chalk()).default.dim(`to ${plugin.prompt}.`)
|
|
)
|
|
),
|
|
[
|
|
(_chalk || _load_chalk()).default.dim(' \u203A Press ') +
|
|
'Enter' +
|
|
(_chalk || _load_chalk()).default.dim(' to trigger a test run.')
|
|
]
|
|
);
|
|
|
|
return messages.filter(message => !!message).join(delimiter) + '\n';
|
|
};
|
|
|
|
const showToggleUsagePrompt = () =>
|
|
'\n' +
|
|
(_chalk || _load_chalk()).default.bold('Watch Usage: ') +
|
|
(_chalk || _load_chalk()).default.dim('Press ') +
|
|
'w' +
|
|
(_chalk || _load_chalk()).default.dim(' to show more.');
|