SQL Operations Studio Public Preview 1 (0.23) release source code

test/electron/renderer.js

@@ -0,0 +1,265 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/*eslint-env mocha*/
+
+const { ipcRenderer } = require('electron');
+const assert = require('assert');
+const path = require('path');
+const glob = require('glob');
+const minimatch = require('minimatch');
+const istanbul = require('istanbul');
+const i_remap = require('remap-istanbul/lib/remap');
+
+let _tests_glob = '**/test/**/*.test.js';
+let loader;
+let _out;
+
+function initLoader(opts) {
+	let outdir = opts.build ? 'out-build' : 'out';
+	_out = path.join(__dirname, `../../${outdir}`);
+
+	// setup loader
+	loader = require(`${_out}/vs/loader`);
+	const loaderConfig = {
+		nodeRequire: require,
+		nodeMain: __filename,
+		catchError: true,
+		baseUrl: path.join(__dirname, '../../src'),
+		paths: {
+			'vs': `../${outdir}/vs`,
+			'lib': `../${outdir}/lib`,
+			'bootstrap': `../${outdir}/bootstrap`
+		}
+	};
+
+	// nodeInstrumenter when coverage is requested
+	if (opts.coverage) {
+		const instrumenter = new istanbul.Instrumenter();
+
+		loaderConfig.nodeInstrumenter = function (contents, source) {
+			return minimatch(source, _tests_glob)
+				? contents // don't instrument tests itself
+				: instrumenter.instrumentSync(contents, source);
+		};
+	}
+
+	loader.require.config(loaderConfig);
+}
+
+function createCoverageReport(opts) {
+	return new Promise(resolve => {
+
+		if (!opts.coverage) {
+			return resolve(undefined);
+		}
+
+		const exclude = /\b((winjs\.base)|(marked)|(raw\.marked)|(nls)|(css))\.js$/;
+		const remappedCoverage = i_remap(global.__coverage__, { exclude: exclude }).getFinalCoverage();
+
+		// The remapped coverage comes out with broken paths
+		function toUpperDriveLetter(str) {
+			if (/^[a-z]:/.test(str)) {
+				return str.charAt(0).toUpperCase() + str.substr(1);
+			}
+			return str;
+		}
+		function toLowerDriveLetter(str) {
+			if (/^[A-Z]:/.test(str)) {
+				return str.charAt(0).toLowerCase() + str.substr(1);
+			}
+			return str;
+		}
+
+		const REPO_PATH = toUpperDriveLetter(path.join(__dirname, '../..'));
+		const fixPath = function (brokenPath) {
+			const startIndex = brokenPath.indexOf(REPO_PATH);
+			if (startIndex === -1) {
+				return toLowerDriveLetter(brokenPath);
+			}
+			return toLowerDriveLetter(brokenPath.substr(startIndex));
+		};
+
+		const finalCoverage = Object.create(null);
+		for (const entryKey in remappedCoverage) {
+			const entry = remappedCoverage[entryKey];
+			entry.path = fixPath(entry.path);
+			finalCoverage[fixPath(entryKey)] = entry;
+		}
+
+		const collector = new istanbul.Collector();
+		collector.add(finalCoverage);
+
+		let coveragePath = path.join(path.dirname(__dirname), '../.build/coverage');
+		let reportTypes = [];
+		if (opts.run || opts.runGlob) {
+			// single file running
+			coveragePath += '-single';
+			reportTypes = ['lcovonly'];
+		} else {
+			reportTypes = ['json', 'lcov', 'html'];
+		}
+
+		const reporter = new istanbul.Reporter(null, coveragePath);
+		reporter.addAll(reportTypes);
+		reporter.write(collector, true, resolve);
+	});
+}
+
+function loadTestModules(opts) {
+
+	if (opts.run) {
+		const files = Array.isArray(opts.run) ? opts.run : [opts.run];
+		const modules = files.map(file => {
+			return path.relative(_out, file).replace(/\.js$/, '');
+		});
+		return new Promise((resolve, reject) => {
+			loader.require(modules, resolve, reject);
+		});
+	}
+
+	const pattern = opts.runGlob || _tests_glob;
+
+	return new Promise((resolve, reject) => {
+		glob(pattern, { cwd: _out }, (err, files) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			const modules = files.map(file => file.replace(/\.js$/, ''));
+			resolve(modules);
+		});
+	}).then(modules => {
+		return new Promise((resolve, reject) => {
+			loader.require(modules, resolve, reject);
+		});
+	});
+}
+
+function loadTests(opts) {
+
+	const _unexpectedErrors = [];
+	const _loaderErrors = [];
+
+	// collect loader errors
+	loader.require.config({
+		onError(err) {
+			_loaderErrors.push(err);
+			console.error(err);
+		}
+	});
+
+	// collect unexpected errors
+	loader.require(['vs/base/common/errors'], function (errors) {
+		errors.setUnexpectedErrorHandler(function (err) {
+			let stack = (err ? err.stack : null);
+			if (!stack) {
+				stack = new Error().stack;
+			}
+
+			_unexpectedErrors.push((err && err.message ? err.message : err) + '\n' + stack);
+		});
+	});
+
+	return loadTestModules(opts).then(() => {
+		suite('Unexpected Errors & Loader Errors', function () {
+			test('should not have unexpected errors', function () {
+				const errors = _unexpectedErrors.concat(_loaderErrors);
+				if (errors.length) {
+					errors.forEach(function (stack) {
+						console.error('');
+						console.error(stack);
+					});
+					assert.ok(false, errors);
+				}
+			});
+		});
+	});
+}
+
+function serializeSuite(suite) {
+	return {
+		title: suite.title,
+		fullTitle: suite.fullTitle(),
+		timeout: suite.timeout(),
+		retries: suite.retries(),
+		enableTimeouts: suite.enableTimeouts(),
+		slow: suite.slow(),
+		bail: suite.bail()
+	};
+}
+
+function serializeRunnable(runnable) {
+	return {
+		title: runnable.title,
+		fullTitle: runnable.fullTitle(),
+		async: runnable.async,
+		slow: runnable.slow(),
+		speed: runnable.speed,
+		duration: runnable.duration
+	};
+}
+
+function serializeError(err) {
+	return {
+		message: err.message,
+		stack: err.stack,
+		actual: err.actual,
+		expected: err.expected,
+		uncaught: err.uncaught,
+		showDiff: err.showDiff,
+		inspect: typeof err.inspect === 'function' ? err.inspect() : ''
+	};
+}
+
+class IPCReporter {
+
+	constructor(runner) {
+		runner.on('start', () => ipcRenderer.send('start'));
+		runner.on('end', () => ipcRenderer.send('end'));
+		runner.on('suite', suite => ipcRenderer.send('suite', serializeSuite(suite)));
+		runner.on('suite end', suite => ipcRenderer.send('suite end', serializeSuite(suite)));
+		runner.on('test', test => ipcRenderer.send('test', serializeRunnable(test)));
+		runner.on('test end', test => ipcRenderer.send('test end', serializeRunnable(test)));
+		runner.on('hook', hook => ipcRenderer.send('hook', serializeRunnable(hook)));
+		runner.on('hook end', hook => ipcRenderer.send('hook end', serializeRunnable(hook)));
+		runner.on('pass', test => ipcRenderer.send('pass', serializeRunnable(test)));
+		runner.on('fail', (test, err) => ipcRenderer.send('fail', serializeRunnable(test), serializeError(err)));
+		runner.on('pending', test => ipcRenderer.send('pending', serializeRunnable(test)));
+	}
+}
+
+function runTests(opts) {
+
+	return loadTests(opts).then(() => {
+
+		if (opts.grep) {
+			mocha.grep(opts.grep);
+		}
+
+		if (!opts.debug) {
+			mocha.reporter(IPCReporter);
+		}
+
+		const runner = mocha.run(() => {
+			createCoverageReport(opts).then(() => {
+				ipcRenderer.send('all done');
+			});
+		});
+
+		if (opts.debug) {
+			runner.on('fail', (test, err) => {
+
+				console.error(test.fullTitle());
+				console.error(err.stack);
+			});
+		}
+	});
+}
+
+ipcRenderer.on('run', (e, opts) => {
+	initLoader(opts);
+	runTests(opts).catch(err => console.error(err));
+});