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

test/all.js

@@ -0,0 +1,294 @@
+/*---------------------------------------------------------------------------------------------
+ *  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*/
+/*global define,run*/
+
+var assert = require('assert');
+var path = require('path');
+var glob = require('glob');
+var istanbul = require('istanbul');
+var i_remap = require('remap-istanbul/lib/remap');
+var jsdom = require('jsdom-no-contextify');
+var minimatch = require('minimatch');
+var fs = require('fs');
+var vm = require('vm');
+// {{SQL CARBON EDIT}}
+var TEST_GLOB = '**/*test*/**/*.test.js';
+
+// {{SQL CARBON EDIT}}
+var SQL_TEST_GLOB = '**/sqltest/**/*.test.js';
+
+var optimist = require('optimist')
+	.usage('Run the Code tests. All mocha options apply.')
+	.describe('build', 'Run from out-build').boolean('build')
+	.describe('run', 'Run a single file').string('run')
+	.describe('coverage', 'Generate a coverage report').boolean('coverage')
+	.describe('only-monaco-editor', 'Run only monaco editor tests').boolean('only-monaco-editor')
+	.describe('forceLoad', 'Force loading').boolean('forceLoad')
+	.describe('browser', 'Run tests in a browser').boolean('browser')
+	.alias('h', 'help').boolean('h')
+	.describe('h', 'Show help');
+
+var argv = optimist.argv;
+
+if (argv.help) {
+	optimist.showHelp();
+	process.exit(1);
+}
+
+var out = argv.build ? 'out-build' : 'out';
+var loader = require('../' + out + '/vs/loader');
+var src = path.join(path.dirname(__dirname), out);
+
+function main() {
+	process.on('uncaughtException', function (e) {
+		console.error(e.stack || e);
+	});
+
+  // {{SQL CARBON EDIT}}
+	var loaderConfig = {
+		nodeRequire: require,
+		nodeMain: __filename,
+		baseUrl: path.join(path.dirname(__dirname), 'src'),
+		paths: {
+			'vs': `../${ out }/vs`,
+			'sqltest': `../${ out }/sqltest`,
+			'sql': `../${ out }/sql`,
+			'lib': `../${ out }/lib`,
+			'bootstrap': `../${ out }/bootstrap`
+		},
+		catchError: true,
+		nodeModules: [
+			'@angular/common',
+			'@angular/core',
+			'@angular/forms',
+			'@angular/platform-browser',
+			'@angular/platform-browser-dynamic',
+			'@angular/router',
+			'angular2-grid',
+			'rxjs/add/observable/of',
+			'rxjs/Observable',
+			'rxjs/Subject',
+			'rxjs/Observer'
+		]
+	};
+
+
+	if (argv.coverage) {
+		var instrumenter = new istanbul.Instrumenter();
+
+		var seenSources = {};
+
+		loaderConfig.nodeInstrumenter = function (contents, source) {
+			seenSources[source] = true;
+
+			if (minimatch(source, SQL_TEST_GLOB)) {
+				return contents;
+			}
+
+			return instrumenter.instrumentSync(contents, source);
+		};
+
+		process.on('exit', function (code) {
+			if (code !== 0) {
+				return;
+			}
+
+			if (argv.forceLoad) {
+        // {{SQL CARBON EDIT}}
+				var allFiles = glob.sync(out + '/sqltest/**/*.js');
+				allFiles = allFiles.map(function(source) {
+					return path.join(__dirname, '..', source);
+				});
+				allFiles = allFiles.filter(function(source) {
+					if (seenSources[source]) {
+						return false;
+					}
+
+          // {{SQL CARBON EDIT}}
+					if (minimatch(source, SQL_TEST_GLOB)) {
+						return false;
+					}
+					if (/fixtures/.test(source)) {
+						return false;
+					}
+					return true;
+				});
+				allFiles.forEach(function(source, index) {
+					var contents = fs.readFileSync(source).toString();
+					contents = instrumenter.instrumentSync(contents, source);
+					var stopAt = contents.indexOf('}\n__cov');
+					stopAt = contents.indexOf('}\n__cov', stopAt + 1);
+
+					var str = '(function() {' + contents.substr(0, stopAt + 1) + '});';
+					var r = vm.runInThisContext(str, source);
+					r.call(global);
+				});
+			}
+
+			let remapIgnores = /\b((winjs\.base)|(marked)|(raw\.marked)|(nls)|(css))\.js$/;
+
+			var remappedCoverage = i_remap(global.__coverage__, { exclude: remapIgnores }).getFinalCoverage();
+
+			// The remapped coverage comes out with broken paths
+			var toUpperDriveLetter = function(str) {
+				if (/^[a-z]:/.test(str)) {
+					return str.charAt(0).toUpperCase() + str.substr(1);
+				}
+				return str;
+			};
+			var toLowerDriveLetter = function(str) {
+				if (/^[A-Z]:/.test(str)) {
+					return str.charAt(0).toLowerCase() + str.substr(1);
+				}
+				return str;
+			};
+
+			var REPO_PATH = toUpperDriveLetter(path.join(__dirname, '..'));
+			var fixPath = function(brokenPath) {
+				var startIndex = brokenPath.indexOf(REPO_PATH);
+				if (startIndex === -1) {
+					return toLowerDriveLetter(brokenPath);
+				}
+				return toLowerDriveLetter(brokenPath.substr(startIndex));
+			};
+
+			var finalCoverage = {};
+			for (var entryKey in remappedCoverage) {
+				var entry = remappedCoverage[entryKey];
+				entry.path = fixPath(entry.path);
+        // {{SQL CARBON EDIT}}
+				if (!entry.path.includes('\\vs\\') && !entry.path.includes('/vs/')) {
+					finalCoverage[fixPath(entryKey)] = entry;
+				}
+			}
+
+			var collector = new istanbul.Collector();
+			collector.add(finalCoverage);
+
+			var coveragePath = path.join(path.dirname(__dirname), '.build', 'coverage');
+			var reportTypes = [];
+			if (argv.run || argv.runGlob) {
+				// single file running
+				coveragePath += '-single';
+				reportTypes = ['lcovonly'];
+			} else {
+        // {{SQL CARBON EDIT}}
+				reportTypes = ['json', 'lcov', 'html', 'cobertura'];
+			}
+			var reporter = new istanbul.Reporter(null, coveragePath);
+			reporter.addAll(reportTypes);
+			reporter.write(collector, true, function () {});
+		});
+	}
+
+	loader.config(loaderConfig);
+
+	global.define = loader;
+	global.document = jsdom.jsdom('<!doctype html><html><body></body></html>');
+	global.self = global.window = global.document.parentWindow;
+
+	global.Element = global.window.Element;
+	global.HTMLElement = global.window.HTMLElement;
+	global.Node = global.window.Node;
+	global.navigator = global.window.navigator;
+	global.XMLHttpRequest = global.window.XMLHttpRequest;
+  // {{SQL CARBON EDIT}}
+	global.Event = global.window.Event;
+
+	require('reflect-metadata');
+	global.window.Reflect = global.Reflect;
+	global.window.Zone = global.Zone;
+
+	var didErr = false;
+	var write = process.stderr.write;
+	process.stderr.write = function (data) {
+		didErr = didErr || !!data;
+		write.apply(process.stderr, arguments);
+	};
+
+	var loadFunc = null;
+
+	if (argv.runGlob) {
+		loadFunc = cb => {
+			const doRun = tests => {
+				const modulesToLoad = tests.map(test => {
+					if (path.isAbsolute(test)) {
+						test = path.relative(src, path.resolve(test));
+					}
+
+					return test.replace(/(\.js)|(\.d\.ts)|(\.js\.map)$/, '');
+				});
+				define(modulesToLoad, () => cb(null), cb);
+			};
+
+			glob(argv.runGlob, { cwd: src }, function (err, files) { doRun(files); });
+		};
+	} else if (argv.run) {
+		var tests = (typeof argv.run === 'string') ? [argv.run] : argv.run;
+		var modulesToLoad = tests.map(function(test) {
+			return path.relative(src, path.resolve(test)).replace(/(\.js)|(\.d\.ts)|(\.js\.map)$/, '');
+		});
+		loadFunc = cb => {
+			define(modulesToLoad, () => cb(null), cb);
+		};
+	} else if (argv['only-monaco-editor']) {
+		loadFunc = function(cb) {
+			glob(TEST_GLOB, { cwd: src }, function (err, files) {
+				var modulesToLoad = files.map(function (file) {
+					return file.replace(/\.js$/, '');
+				});
+				modulesToLoad = modulesToLoad.filter(function(module) {
+					if (/^vs\/workbench\//.test(module)) {
+						return false;
+					}
+					// platform tests drag in the workbench.
+					// see https://github.com/Microsoft/vscode/commit/12eaba2f64c69247de105c3d9c47308ac6e44bc9
+					// and cry a little
+					if (/^vs\/platform\//.test(module)) {
+						return false;
+					}
+					return !/(\/|\\)node(\/|\\)/.test(module);
+				});
+				console.log(JSON.stringify(modulesToLoad, null, '\t'));
+				define(modulesToLoad, function () { cb(null); }, cb);
+			});
+		};
+	} else {
+		loadFunc = function(cb) {
+			glob(TEST_GLOB, { cwd: src }, function (err, files) {
+				var modulesToLoad = files.map(function (file) {
+					return file.replace(/\.js$/, '');
+				});
+				define(modulesToLoad, function () { cb(null); }, cb);
+			});
+		};
+	}
+
+	loadFunc(function(err) {
+		if (err) {
+			console.error(err);
+			return process.exit(1);
+		}
+
+		process.stderr.write = write;
+
+		// replace the default unexpected error handler to be useful during tests
+		loader(['vs/base/common/errors'], function(errors) {
+			errors.setUnexpectedErrorHandler(function (err) {
+			});
+
+			// fire up mocha
+			run();
+		});
+	});
+}
+
+if (process.argv.some(function (a) { return /^--browser/.test(a); })) {
+	require('./browser');
+} else {
+	main();
+}