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

test/electron/index.js

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const { app, BrowserWindow, ipcMain } = require('electron');
+const { tmpdir } = require('os');
+const { join } = require('path');
+const path = require('path');
+const mocha = require('mocha');
+const events = require('events');
+
+const optimist = require('optimist')
+	.describe('grep', 'only run tests matching <pattern>').alias('grep', 'g').alias('grep', 'f').string('grep')
+	.describe('run', 'only run tests from <file>').string('run')
+	.describe('runGlob', 'only run tests matching <file_pattern>').alias('runGlob', 'runGrep').string('runGlob')
+	.describe('build', 'run with build output (out-build)').boolean('build')
+	.describe('coverage', 'generate coverage report').boolean('coverage')
+	.describe('debug', 'open dev tools, keep window open, reuse app data').string('debug')
+	.describe('reporter', 'the mocha reporter').string('reporter').default('reporter', process.platform === 'win32' ? 'dot' : 'spec')
+	.describe('help', 'show the help').alias('help', 'h');
+
+const argv = optimist.argv;
+
+if (argv.help) {
+	optimist.showHelp();
+	process.exit(0);
+}
+
+if (!argv.debug) {
+	app.setPath('userData', join(tmpdir(), `vscode-tests-${Date.now()}`));
+}
+
+function deserializeSuite(suite) {
+	return {
+		title: suite.title,
+		fullTitle: () => suite.fullTitle,
+		timeout: () => suite.timeout,
+		retries: () => suite.retries,
+		enableTimeouts: () => suite.enableTimeouts,
+		slow: () => suite.slow,
+		bail: () => suite.bail,
+	};
+}
+
+function deserializeRunnable(runnable) {
+	return {
+		title: runnable.title,
+		fullTitle: () => runnable.fullTitle,
+		async: runnable.async,
+		slow: () => runnable.slow,
+		speed: runnable.speed,
+		duration: runnable.duration
+	};
+}
+
+function deserializeError(err) {
+	const inspect = err.inspect;
+	err.inspect = () => inspect;
+	return err;
+}
+
+class IPCRunner extends events.EventEmitter {
+
+	constructor() {
+		super();
+
+		this.didFail = false;
+
+		ipcMain.on('start', () => this.emit('start'));
+		ipcMain.on('end', () => this.emit('end'));
+		ipcMain.on('suite', (e, suite) => this.emit('suite', deserializeSuite(suite)));
+		ipcMain.on('suite end', (e, suite) => this.emit('suite end', deserializeSuite(suite)));
+		ipcMain.on('test', (e, test) => this.emit('test', deserializeRunnable(test)));
+		ipcMain.on('test end', (e, test) => this.emit('test end', deserializeRunnable(test)));
+		ipcMain.on('hook', (e, hook) => this.emit('hook', deserializeRunnable(hook)));
+		ipcMain.on('hook end', (e, hook) => this.emit('hook end', deserializeRunnable(hook)));
+		ipcMain.on('pass', (e, test) => this.emit('pass', deserializeRunnable(test)));
+		ipcMain.on('fail', (e, test, err) => {
+			this.didFail = true;
+			this.emit('fail', deserializeRunnable(test), deserializeError(err));
+		});
+		ipcMain.on('pending', (e, test) => this.emit('pending', deserializeRunnable(test)));
+	}
+}
+
+app.on('ready', () => {
+
+	const win = new BrowserWindow({
+		height: 600,
+		width: 800,
+		show: false,
+		webPreferences: {
+			backgroundThrottling: false,
+			webSecurity: false
+		}
+	});
+
+	win.webContents.on('did-finish-load', () => {
+		if (argv.debug) {
+			win.show();
+			win.webContents.openDevTools('right');
+		}
+		win.webContents.send('run', argv);
+	});
+
+	win.loadURL(`file://${__dirname}/renderer.html`);
+
+	const reporterPath = path.join(path.dirname(require.resolve('mocha')), 'lib', 'reporters', argv.reporter);
+	let Reporter;
+
+	try {
+		Reporter = require(reporterPath);
+	} catch (err) {
+		console.warn(`could not load reporter: ${argv.reporter}`);
+		Reporter = process.platform === 'win32' ? mocha.reporters.Dot : mocha.reporters.Spec;
+	}
+
+	const runner = new IPCRunner();
+	new Reporter(runner);
+
+	if (!argv.debug) {
+		ipcMain.on('all done', () => app.exit(runner.didFail ? 1 : 0));
+	}
+});

test/electron/renderer.html

@@ -0,0 +1,19 @@
+<html>
+
+<head>
+	<meta charset="utf-8">
+	<title>VSCode Tests</title>
+	<link href="../../node_modules/mocha/mocha.css" rel="stylesheet" />
+</head>
+
+<body>
+	<div id="mocha"></div>
+	<script src="../../node_modules/mocha/mocha.js"></script>
+
+	<script>
+		mocha.setup('tdd');
+		require('./renderer');
+	</script>
+</body>
+
+</html>

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));
+});