before ( () => {
patchJsDom(fixture);
// Must load MDL after jsdom, see: https://github.com/mochajs/mocha/issues/1722
requireUncached( 'material-design-lite/material');
global.componentHandler = window.componentHandler;
assert.isObject(componentHandler, 'No global MDL component handler');
requireUncached('../../src/lightboard/lightboard');
assert.isNotNull(window.MaterialExtLightboard, 'Expected MaterialExtAccordion not to be null');
global.MaterialExtLightboard = window.MaterialExtLightboard;
});
before ( () => {
jsdomify.create(fixture);
// Must load MDL after jsdom, see: https://github.com/mochajs/mocha/issues/1722
requireUncached( 'material-design-lite/material');
global.componentHandler = window.componentHandler;
assert.isObject(componentHandler, 'No global MDL component handler');
requireUncached( '../../src/selectfield/selectfield' );
assert.isNotNull(window.MaterialExtSelectfield, 'Expected MaterialExtSelectfield not to be null');
global.MaterialExtSelectfield = window.MaterialExtSelectfield;
//global.componentHandler.upgradeAllRegistered();
//global.componentHandler.upgradeDom();
});
function getWebpackStats() {
if (process.env.NODE_ENV === 'production') {
return require('../public/build/webpack-stats.json');
}
return requireUncached('../public/build/webpack-stats.json');
}
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.equal(getAuthToken('//registry.foobar.eu'), undef)
assert.equal(getAuthToken('//registry.foobar.com'), undef)
done()
})
test.serial('sync without spawn', t => {
const beforeTest = {};
// unset env vars and cache for restoration
unsetEnvVars(beforeTest);
// mock child_process.execFileSync
if (childProcess.execFileSync) {
beforeTest.childProcessExecFileSync = childProcess.execFileSync;
childProcess.execFileSync = () => {
t.false('Attempted to spawn subprocess');
};
}
// test sync method
const locale = requireUncached('./').sync({spawn: false});
console.log('Locale identifier:', locale);
t.is(locale, expectedFallback, 'Locale did not match expected fallback');
// restore env vars and undo mock
restoreEnvVars(beforeTest);
if (beforeTest.childProcessExecFileSync) {
childProcess.execFileSync = beforeTest.childProcessExecFileSync;
}
});
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(getAuthToken(), {token: 'foobar', type: 'Bearer'})
delete process.env[environmentVariable]
done()
})
function getServerModule() {
if (process.env.NODE_ENV === 'production') {
return require('./build/main');
}
return requireUncached('./build/main');
}
exports.requireTestRes = function (resource) {
if (endsWith(resource, '.html') || endsWith(resource, '.txt')) {
return fs.readFileSync('./src/test/resources/' + resource, "utf-8");
} else {
return requireUncached('../resources/' + resource);
}
}
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
var token = getAuthToken()
assert.deepEqual(token, {token: 'Zm9vYmFyOmZvb2Jhcg==', type: 'Basic'})
assert.equal(decodeBase64(token.token), 'foobar:foobar')
done()
})
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
var token = getAuthToken('//registry.blah.foo')
assert.deepEqual(token, {token: 'YmFyYmF6OmJhcmJheQ==', type: 'Basic'})
assert.equal(decodeBase64(token.token), 'barbaz:barbay')
done()
})
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('./index')
assert(!err, err)
assert.equal(getAuthToken('https://registry.blah.com/foo/bar/baz', opts), 'whatev')
assert.equal(getAuthToken('http://registry.blah.eu/what/ever', opts), 'yep')
assert.equal(getAuthToken('//some.registry', opts), undef)
done()
})
module.exports = function (options) {
options = options || {};
var miniJasmineLib = requireUncached('minijasminenode');
var color = process.argv.indexOf('--no-color') === -1;
var reporter = options.reporter;
if (reporter) {
(Array.isArray(reporter) ? reporter : [reporter]).forEach(function (el) {
miniJasmineLib.addReporter(el);
});
}
return through.obj(function (file, enc, cb) {
if (file.isNull()) {
cb(null, file);
return;
}
if (file.isStream()) {
cb(new gutil.PluginError('gulp-jasmine', 'Streaming not supported'));
return;
}
/**
* Get the cache object of the specs.js file,
* get its children and delete the childrens cache
*/
var modId = require.resolve(path.resolve(file.path));
var files = require.cache[modId];
if (typeof files !== 'undefined') {
for (var i in files.children) {
delete require.cache[files.children[i].id];
}
}
delete require.cache[modId];
miniJasmineLib.addSpecs(file.path);
cb(null, file);
}, function (cb) {
try {
miniJasmineLib.executeSpecs({
isVerbose: options.verbose,
includeStackTrace: options.includeStackTrace,
defaultTimeoutInterval: options.timeout,
showColors: color,
onComplete: function (passed) {
cb(passed ? null : new gutil.PluginError('gulp-jasmine', 'Tests failed', {
showStack: false
}));
}
});
} catch (err) {
cb(new gutil.PluginError('gulp-jasmine', err));
}
});
};
fs.writeFile(npmRcPath, '//contoso.pkgs.visualstudio.com/_packaging/MyFeed/npm/:_authToken=heider', function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(
getAuthToken('https://contoso.pkgs.visualstudio.com/_packaging/MyFeed/npm/registry'),
{token: 'heider', type: 'Bearer'}
)
done()
})
/**
* Loads a JavaScript configuration from a file.
* @param {string} filePath The filename to load.
* @returns {Object} The configuration object from the file.
* @throws {Error} If the file cannot be read.
* @private
*/
function loadJSConfigFile(filePath) {
debug(`Loading JS config file: ${filePath}`);
try {
return requireUncached(filePath);
} catch (e) {
debug(`Error reading JavaScript file: ${filePath}`);
e.message = `Cannot read config file: ${filePath}\nError: ${e.message}`;
throw e;
}
}
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(getAuthToken('https://registry.blah.edu/foo/bar/baz', opts), {token: 'recurseNoLevel', type: 'Bearer'})
assert.deepEqual(getAuthToken('https://registry.blah.org/foo/bar/baz', opts), {token: 'recurseExactlyOneLevel', type: 'Bearer'})
assert.deepEqual(getAuthToken('https://registry.blah.com/foo/bar/baz', opts), {token: 'whatev', type: 'Bearer'})
assert.deepEqual(getAuthToken('http://registry.blah.eu/what/ever', opts), {token: 'yep', type: 'Bearer'})
assert.equal(getAuthToken('//some.registry', opts), undef)
done()
})
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
const npmrc = {
'registry': 'http://registry.foobar.eu/',
'//registry.foobar.eu/:_authToken': 'qar'
}
assert.deepEqual(getAuthToken({npmrc: npmrc}), {token: 'qar', type: 'Bearer'})
done()
})
/**
* Loads a JavaScript configuration from a file.
* @param {string} filePath The filename to load.
* @returns {Object} The configuration object from the file.
* @throws {Error} If the file cannot be read.
* @private
*/
function loadJSConfigFile(filePath) {
debug("Loading JS config file: " + filePath);
try {
return requireUncached(filePath);
} catch (e) {
debug("Error reading JavaScript file: " + filePath);
e.message = "Cannot read config file: " + filePath + "\nError: " + e.message;
throw e;
}
}
test.cb('async', t => {
t.plan(3);
requireUncached('./')((err, locale) => {
console.log('Locale identifier:', locale);
t.ifError(err);
t.true(locale.length > 1);
t.not(locale.indexOf('_'), -1);
t.end();
});
});
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
var token = getAuthToken('https://registry.blah.com/foo/bar/baz', opts)
assert.deepEqual(token, {token: 'YmFyYmF6OmJhcmJheQ==', type: 'Basic'})
assert.equal(decodeBase64(token.token), 'barbaz:barbay')
token = getAuthToken('https://registry.blah.eu/foo/bar/baz', opts)
assert.deepEqual(token, {token: 'YmFyYmF6OmZvb2Jheg==', type: 'Basic'})
assert.equal(decodeBase64(token.token), 'barbaz:foobaz')
assert.equal(getAuthToken('//some.registry', opts), undef)
done()
})
fs.writeFile(filePath, code, 'utf8', function(err) {
if(err) {
callback(err, null);
} else {
try {
var result = requireUncached(fileDir + '/test.js').testCode()
callback(null, result);
} catch(e) {
callback(e, null);
}
}
})
function getCustomConf(env) {
let webpackConfJs = path.join(projectRoot, 'webpack.config.js')
try {
let conf = requireUncached(webpackConfJs)
return conf({
babel: babelrc,
eslint: eslintrc,
postcss: getPostcssrc(env)
})
} catch (e) {
return {}
}
}
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
var token = getAuthToken()
assert.deepEqual(token, {
type: 'Basic',
username: '******',
password: '******',
token: 'dXNlcm5hbWU6cGFzc3dvcmQ='
})
assert.equal(decodeBase64(token.token), 'username:password')
delete process.env[environmentVariable]
done()
})
beforeEach(() => {
helper = requireNew('../../src/helpers/gitinfo.js');
context = {
gitdown: {
getConfig: () => {
return {
gitinfo: {
gitPath: __dirname
}
};
}
}
};
});
/**
* Loads the presenter from presenters directory.
*
* @method loadPresenter
*
* @param {String} presenter
*
* @return {String}
*/
loadPresenter (presenter, clearCache = false) {
/**
* Presenters path has not been registered and trying
* to load a presenter.
*/
if (!this.presentersPath) {
throw CE.RuntimeException.unregisterdPresenters(presenter)
}
try {
const presenterPath = path.join(this.presentersPath, presenter)
return clearCache ? requireUncached(presenterPath) : require(presenterPath)
} catch (error) {
if (error.code === 'MODULE_NOT_FOUND') {
throw CE.RuntimeException.missingPresenter(presenter, this.presentersPath)
}
throw error
}
}
test.cb.serial('async without spawn', t => {
t.plan(3);
const beforeTest = {};
// unset env vars and cache for restoration
unsetEnvVars(beforeTest);
// mock child_process.execFile
beforeTest.childProcessExecFile = childProcess.execFile;
childProcess.execFile = () => {
const args = Array.prototype.slice.call(arguments);
const execFileCb = args[args.length - 1];
if (typeof execFileCb === 'function') {
// passing Error here causes osLocale callback not to be called
execFileCb(null, 'spawn_NOTALLOWED');
}
};
// callback to restore env vars and undo mock
const afterTest = () => {
restoreEnvVars(beforeTest);
childProcess.execFile = beforeTest.childProcessExecFile;
};
// test async method
requireUncached('./')({spawn: false}, (err, locale) => {
console.log('Locale identifier:', locale);
afterTest();
t.ifError(err);
t.is(locale, expectedFallback, 'Locale did not match expected fallback');
t.not(locale, 'spawn_NOTALLOWED', 'Attempted to spawn subprocess');
t.end();
});
});
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(getAuthToken(), {token: 'beepboop', type: 'Bearer'})
done()
})
fs.writeFile(npmRcPath, 'registry=http://registry.npmjs.eu/', function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert(!getAuthToken())
done()
})
it('should read global if no local is found', function () {
var getAuthToken = requireUncached('../index')
getAuthToken()
})
fs.writeFile(npmRcPath, content, function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(getAuthToken('//registry.foobar.eu'), {token: 'bearerToken', type: 'Bearer'})
done()
})
fs.writeFile(npmRcPath, '//registry.blah.com:_authToken=whatev', function (err) {
var getAuthToken = requireUncached('../index')
assert(!err, err)
assert.deepEqual(getAuthToken('https://registry.blah.com'), {token: 'whatev', type: 'Bearer'})
done()
})