var runner = function runner(opts) {
opts = opts || {};
if (options.captureExceptions) {
// Grunt will kill the process when it handles an uncaughtException, so we need to
// remove their handler to allow the test suite to continue.
// A downside of this is that we ignore any other registered `ungaughtException`
// handlers.
process.removeAllListeners('uncaughtException');
process.on('uncaughtException', function onUncaught(e) {
grunt.log.error('Caught unhandled exception: ', e.toString());
grunt.log.error(e.stack);
});
}
try {
var jasmine = new Jasmine();
jasmine.loadConfig(options.jasmine);
addReporters(jasmine);
jasmine.onComplete(function jasmineComplete(passed) {
options.onComplete(passed, opts);
});
jasmine.execute();
}
catch (error) {
grunt.log.error('Jasmine runner failed: ' + error.stack);
if (options.forceExit) {
throw error;
}
else {
done(error);
}
}
};
}, function (cb) {
var self = this;
try {
if (jasmine.helperFiles) {
jasmine.helperFiles.forEach(function (helper) {
var resolvedPath = path.resolve(helper);
var modId = require.resolve(resolvedPath);
deleteRequireCache(modId);
});
}
jasmine.onComplete(function (passed) {
if (errorOnFail && !passed) {
cb(new gutil.PluginError('gulp-jasmine', 'Tests failed', {
showStack: false
}));
} else {
self.emit('jasmineDone', passed);
cb();
}
});
jasmine.execute();
} catch (err) {
cb(new gutil.PluginError('gulp-jasmine', err, {showStack: true}));
}
});
function nodeTest(specFiles, cb) {
// load zone-node here to let jasmine be able to use jasmine.clock().install()
// without throw error
require('./build/lib/node/rollup-main');
var args = process.argv;
if (args.length > 3) {
require('./build/test/test-env-setup-jasmine' + args[3]);
}
var JasmineRunner = require('jasmine');
var jrunner = new JasmineRunner();
jrunner.configureDefaultReporter({showColors: true});
jrunner.onComplete(function(passed) {
if (!passed) {
var err = new Error('Jasmine node tests failed.');
// The stack is not useful in this context.
err.showStack = false;
cb(err);
} else {
cb();
}
});
jrunner.print = function(value) {
process.stdout.write(value);
};
jrunner.addReporter(new JasmineRunner.ConsoleReporter(jrunner));
jrunner.projectBaseDir = __dirname;
jrunner.specDir = '';
jrunner.addSpecFiles(specFiles);
jrunner.execute();
}
jasmine.onComplete(function(passed) {
if(passed) {
var Jasmine = require('jasmine'), jasmine = new Jasmine;
var reporter = require('../utilities/reporting/junit_reporter.js');
var junitReporter3 = new reporter.JUnitXmlReporter({
savePath: './utilities/reporting/',
consolidateAll: true,
stylesheet: 'junitresults.xsl'
});
jasmine.loadConfig({
spec_dir: './tests/level3/'+setToRun,
spec_files: ['**/*.js']
});
jasmine.configureDefaultReporter({ showColors: true });
jasmine.addReporter(junitReporter3);
jasmine.onComplete(function(passed) {
if(passed) {
console.log('All Level 3 tests passed');
hipchat.report(true);
}
else {
console.log('At least one Level 3 test failed');
hipchat.report(false);
}
});
jasmine.execute();
}
else {console.log('At least one Level 2 test failed');}
});
function(callback) {
gutil.log('Running Jasmine in Node');
try {
var jasmine = new Jasmine(),
terminalReporter = require('./lib/terminal-reporter.js').TerminalReporter;
jasmine.addReporter(new terminalReporter(_.defaults(gulpOptions, {showColors: true})));
jasmine.loadConfig({
random: _.get(gulpOptions, 'random', false),
spec_files: filePaths
});
if (_.has(gulpOptions, 'seed')) {
jasmine.seed(gulpOptions.seed);
}
jasmine.onComplete(function(passed) {
callback(null);
});
jasmine.execute();
} catch(error) {
callback(new gutil.PluginError('gulp-jasmine-phantom', error));
}
}
gulp.task('test', (done) => {
// setup Jasmine
const jasmine = new Jasmine();
jasmine.loadConfig({
spec_dir: 'spec',
spec_files: ['**/*[sS]pec.js'],
helpers: ['helpers/**/*.js'],
random: false,
seed: null,
stopSpecOnExpectationFailure: false
});
jasmine.jasmine.DEFAULT_TIMEOUT_INTERVAL = 15000;
// setup console reporter
const reporter = new JasmineConsoleReporter({
colors: 1, // (0|false)|(1|true)|2
cleanStack: 1, // (0|false)|(1|true)|2|3
verbosity: 4, // (0|false)|1|2|(3|true)|4
listStyle: 'indent', // "flat"|"indent"
activity: false
});
// initialize and execute
jasmine.onComplete(passed => {done()});
jasmine.env.clearReporters();
jasmine.addReporter(reporter);
jasmine.execute();
});
return q.promise(function(resolve, reject) {
if (jasmineNodeOpts && jasmineNodeOpts.defaultTimeoutInterval) {
jasmine.DEFAULT_TIMEOUT_INTERVAL = jasmineNodeOpts.defaultTimeoutInterval;
}
var originalOnComplete = runner.getConfig().onComplete;
jrunner.onComplete(function(passed) {
try {
var completed = q();
if (originalOnComplete) {
completed = q(originalOnComplete(passed));
}
completed.then(function() {
resolve({
failedCount: reporter.failedCount,
specResults: reporter.testResult
});
});
} catch (err) {
reject(err);
}
});
jrunner.configureDefaultReporter(jasmineNodeOpts);
jrunner.projectBaseDir = '';
jrunner.specDir = '';
jrunner.addSpecFiles(specs);
jrunner.execute();
});
gulp.task('test', function (done) {
var jasmine = new Jasmine();
jasmine.loadConfigFile('specs/jasmine.json');
jasmine.addReporter(new jasmineSpecReporter.SpecReporter({
displaySuccessfulSpec: !defined(argv.suppressPassed) || !argv.suppressPassed
}));
jasmine.execute();
jasmine.onComplete(function (passed) {
done(argv.failTaskOnError && !passed ? 1 : 0);
});
});
var runJasmine = function (callback) {
gutil.log('run jasmine tests');
/**
* save session ID
*/
sessionID = GLOBAL.browser.requestHandler.sessionID;
jasmine.onComplete(next(callback));
jasmine.execute();
};
function() {
var done = this.async(),
Jasmine = require('jasmine'),
jasmineCore = require('./lib/jasmine-core.js'),
jasmine = new Jasmine({jasmineCore: jasmineCore});
jasmine.loadConfigFile('./spec/support/jasmine.json');
jasmine.onComplete(function(passed) {
done(passed);
});
jasmine.execute();
}
/* --------------------------------------------- */
/* -------- private functions -------- */
/* --------------------------------------------- */
// initialises jasmine and the reporters
function initialiseJasmine(browser) {
// remove any cached tests
logger.debug('Removing cached node resources for Jasmine', logfile);
var modId = require.resolve('jasmine');
deleteRequireCache(modId);
// initialise the new objects
logger.debug('Configuring Jasmine and the reporters', logfile);
var jasmine = new Jasmine();
var jsonReporter = new JsonReporter();
// add the custom reporter
jasmine.addReporter(jsonReporter);
// set options
if (runner.config.runner.timeout) {
jasmine.jasmine.DEFAULT_TIMEOUT_INTERVAL = runner.config.runner.timeout;
}
if (runner.window) {
jsonReporter.test = runner.test;
jsonReporter.config = runner.config;
jsonReporter.window = runner.window;
jsonReporter.testRunsLeft = testRunsLeft;
jsonReporter.browser = browser;
}
// add the config
jasmine.projectBaseDir = app.getAppPath();
jasmine.loadConfig({
spec_dir: 'testing',
spec_files: [
'**/*.js'
],
helpers: []
});
// track when jasmine completes
jasmine.onComplete((result) => {
jasmineCompleted(result);
});
return jasmine;
}
grunt.registerMultiTask(NAME, DESCRIPTION, function jasmineTask() {
var done = this.async();
var options = this.options({
configure: function() {},
defaultReporter: {}
});
var files = this.filesSrc;
var jasmine = new Jasmine();
jasmine.loadConfig({
spec_files: files,
spec_dir: ''
});
options.configure(jasmine);
jasmine.configureDefaultReporter(options.defaultReporter);
jasmine.onComplete(done);
jasmine.execute();
});
gulp.task('test', done => {
var jasmine = new Jasmine();
jasmine.loadConfig({
spec_dir: './test',
spec_files: ['./**/*_spec.js']
});
jasmine.onComplete(passed => {
if (passed) {
console.log('All specs passed');
} else {
console.log('One or more specs failed');
}
done();
});
jasmine.execute();
});
gulp.task('test/node', ['compile'], function(cb) {
var JasmineRunner = require('jasmine');
var jrunner = new JasmineRunner();
var specFiles = ['build/test/node_entry_point.js'];
jrunner.configureDefaultReporter({showColors: true});
jrunner.onComplete(function(passed) {
if (!passed) {
var err = new Error('Jasmine node tests failed.');
// The stack is not useful in this context.
err.showStack = false;
cb(err);
} else {
cb();
}
});
jrunner.projectBaseDir = __dirname;
jrunner.specDir = '';
jrunner.addSpecFiles(specFiles);
jrunner.execute();
});
out += ' (see ' + error.specUrl + ')';
}
out += ' [' + error.category + ']\n';
}
expect(out).toBe(severalErrorsOut);
done();
})
.catch(function(error) {
fail(error);
done();
});
});
it('handles syntax errors in validator file', function(done) {
// Note: This points the library at a file that's not even Javascript.
ampValidator.getInstance(/*validatorJs*/ 'dist/validator.protoascii')
.then(function(instance) {
fail('We should not get here since this is not a good validator.');
done();
})
.catch(function(error) {
expect(error.message)
.toBe(
'Could not instantiate validator.js - Unexpected token ILLEGAL');
done();
});
});
jasmine.onComplete(function(passed) { process.exit(passed ? 0 : 1); });
jasmine.execute();
if (args[i] === '--coverage') {
doCoverage = true;
break;
}
}
var Jasmine = require('jasmine');
var jasmine = new Jasmine();
var istanbulRunReports = require('./istanbul');
jasmine.onComplete(function(passed) {
// Restore console functions so reports work
for (var name in global.console) {
console[name] = _console[name];
}
// if the tests were instrumented, run the reports
if (global.__coverage__) {
istanbulRunReports();
}
var failedTests = !passed;
process.exit(failedTests);
});
// Override console methods as spies
// Allows test to run without output getting into test output
global._console = {};
for (var name in global.console) {
_console[name] = console[name].bind(console);
console[name] = jasmine.jasmine.createSpy('console.' + name);
}
//MAYBE: Test with injected mocks: http://vue-loader.vuejs.org/en/workflow/testing-with-mocks.html
//MAYBE: USe Minilog for logging. With streams. http://mixu.net/minilog/
var Jasmine = require('jasmine');
var loglevel = require("loglevel")
var log = loglevel.getLogger("runJasmine");
var chalk = require('chalk')
var Config = require('merge-config');
// =================================================================================
// Configure JASMINE test framework
// =================================================================================
var jasmine = new Jasmine({projectBaseDir: __dirname});
jasmine.loadConfigFile(__dirname+'/jasmineConf.json');
jasmine.onComplete(function(passed) {
mockLiquidoBackend.stopHttpServer();
});
// Merge environment variables from test.env.js into process.env
var config = new Config();
config.env(); // Add all existing environment variables into configuration
//config.argv(); // Add all command-line arguments into merged configuration
config.merge(require('../../config/test.env.js')); // Merge test specific env variables
process.env = config.get();
// =================================================================================
// Nice colorful jasmine reports for the console
// https://github.com/onury/jasmine-console-reporter
// =================================================================================
var JasmineConsoleReporter = require('jasmine-console-reporter');
var reporter = new JasmineConsoleReporter({
#!/usr/bin/env node
'use strict';
require('../lib/bootstrap-local');
const glob = require('glob');
const path = require('path');
const Jasmine = require('jasmine');
const projectBaseDir = path.join(__dirname, '../packages');
// Create a Jasmine runner and configure it.
const jasmine = new Jasmine({ projectBaseDir: projectBaseDir });
jasmine.loadConfig({});
// Manually set exit code (needed with custom reporters)
jasmine.onComplete((success) => process.exitCode = !success);
// Run the tests.
const allTests =
glob.sync('packages/**/*.spec.ts')
.map(p => path.relative(projectBaseDir, p))
.filter(p => !/blueprints/.test(p));
jasmine.execute(allTests);
exports.run = function(config, specs, capabilities) {
var Jasmine = require('jasmine'),
jrunner = new Jasmine(),
jasmineNodeOpts = config.jasmineNodeOpts,
jasmineDefaultTimeout = 60000,
defer = q.defer();
jrunner.projectBaseDir = '';
jrunner.specDir = '';
jrunner.addSpecFiles(specs);
if (jasmineNodeOpts && jasmineNodeOpts.defaultTimeoutInterval) {
jasmine.DEFAULT_TIMEOUT_INTERVAL = jasmineNodeOpts.defaultTimeoutInterval;
} else {
jasmine.DEFAULT_TIMEOUT_INTERVAL = jasmineDefaultTimeout;
}
var reporter = new JasmineReporter(capabilities);
jrunner.addReporter(reporter);
// Filter specs to run based on jasmineNodeOpts.grep and jasmineNodeOpts.invert.
jasmine.getEnv().specFilter = function(spec) {
var grepMatch = !jasmineNodeOpts || !jasmineNodeOpts.grep || spec.getFullName().match(new RegExp(jasmineNodeOpts.grep)) !== null;
var invertGrep = !!(jasmineNodeOpts && jasmineNodeOpts.invertGrep);
if (grepMatch == invertGrep) {
spec.pend();
}
return true;
};
/**
* enable expectHandler
*/
if(typeof jasmineNodeOpts.expectationResultHandler === 'function') {
var old = jasmine.Spec.prototype.addExpectationResult;
jasmine.Spec.prototype.addExpectationResult = function(passed, data) {
try {
jasmineNodeOpts.expectationResultHandler.call(browser, passed, data);
} catch(e) {
/**
* propagate expectationResultHandler error if actual assertion passed
*/
if(passed) {
passed = false;
data = {
passed: false,
message: 'expectationResultHandlerError: ' + e.message
};
}
}
return old.call(this, passed, data);
};
}
['it', 'beforeEach', 'beforeAll', 'afterEach', 'afterAll'].forEach(promisify);
/**
* enable generators if supported
*/
if(hasES6Support) {
['it', 'beforeEach', 'beforeAll', 'afterEach', 'afterAll'].forEach(runInGenerator);
}
jrunner.onComplete(function() {
defer.resolve(reporter._failedCount);
});
q(config.before()).then(function() {
try {
jrunner.execute();
} catch(e) {
defer.reject({
message: e.message,
stack: e.stack
});
}
}, defer.reject.bind(defer));
return defer.promise;
};
var jrunner = new JasmineRunner();
// Tun on full stack traces in errors to help debugging
Error.stackTraceLimit = Infinity;
jrunner.jasmine.DEFAULT_TIMEOUT_INTERVAL = 100;
// Support passing multiple globs
var globsIndex = process.argv.indexOf('--');
var args;
if (globsIndex < 0) {
args = [process.argv[2]];
} else {
args = process.argv.slice(globsIndex + 1);
}
var specFiles = args.map(function(globstr) { return glob.sync(globstr); })
.reduce(function(specFiles, paths) { return specFiles.concat(paths); }, []);
jasmine.DEFAULT_TIMEOUT_INTERVAL = 100;
jrunner.configureDefaultReporter({showColors: process.argv.indexOf('--no-color') === -1});
jrunner.onComplete(function(passed) { process.exit(passed ? 0 : 1); });
jrunner.projectBaseDir = path.resolve(__dirname, '../../');
jrunner.specDir = '';
jrunner.addSpecFiles(specFiles);
require('./test-cjs-main.js');
jrunner.execute();
spec_dir: 'spec',
spec_files: [
'appSpec.js',
'requests/**/*[sS]pec.js',
'utils/**/*[sS]pec.js'
],
files: [
"bower_components/angular/angular.min.js",
"bower_components/angular-mocks/angular-mocks.js",
"app/main.js"
]
});
var CustomReporter = require('jasmine-spec-reporter');
var customReporter = new CustomReporter({
displayPendingSpec: true,
displaySpecDuration: true,
displaySuiteNumber: true
});
jasmine.addReporter(customReporter);
jasmine.onComplete(function(passed) {
if(passed) {
console.log('All specs have passed');
}
else {
console.log('At least one spec has failed');
}
});
jasmine.execute();
helpers: ['helpers/**/*.js']
});
/**
* By default, if an exception is thrown in an asynchronous function (in the
* System-Under-Test), the whole Jasmine test run is interrupted. Here, we
* handle the uncaughtException to continue.
*/
process.on('uncaughtException',function(e) {
console.log('Caught unhandled exception (probably in some of your async code): ' + e.toString());
console.log(e.stack);
});
jasmine.onComplete(function(passed) {
console.log("Validation completed.");
});
/**
* Note that adding one custom reporter will disable the default Console
* reporter. We can add it back
*/
jasmine.configureDefaultReporter({});
/**
* We can now launch the Jasmine test runner
*/
jasmine.execute();