it('should execute the code block wtih the right server', function() {
var server1Count = 0, server2Count = 0;
var proEnv = 'production', serverType1 = 'server1', serverType2 = 'server2';
app.init({base: mockBase});
app.set('serverType', serverType1);
app.set('env', proEnv);
app.configure(proEnv, serverType1, function() {
server1Count++;
});
app.configure(proEnv, serverType2, function() {
server2Count++;
});
app.set('serverType', serverType2);
app.configure(proEnv, serverType1, function() {
server1Count++;
});
app.configure(proEnv, serverType2, function() {
server2Count++;
});
server1Count.should.equal(1);
server2Count.should.equal(1);
});
it('should execute the code block wtih the right environment', function() {
var proCount = 0, devCount = 0;
var proEnv = 'production', devEnv = 'development', serverType = 'server';
app.init({base: mockBase});
app.set('serverType', serverType);
app.set('env', proEnv);
app.configure(proEnv, serverType, function() {
proCount++;
});
app.configure(devEnv, serverType, function() {
devCount++;
});
app.set('env', devEnv);
app.configure(proEnv, serverType, function() {
proCount++;
});
app.configure(devEnv, serverType, function() {
devCount++;
});
proCount.should.equal(1);
devCount.should.equal(1);
});
getComponent = function(name){
var
comp = require(eco.getPathComponent(name)),
bootSig = '$__booted$$';
if(comp[bootSig] === undefined) {
// on the fly extension of components
_.extend(comp,{
isDebugging: log.isDebugging,
log: log,
logDebug: log.debug,
logInfo: log.info,
logWarn: log.warn,
logError: log.error
});
if(_.isFunction(comp.configure)) {
comp.configure(eco, config);
}
comp[bootSig] = true;
}
return comp;
},
it('should not register the socket for containers', function () {
conf.type = 'container';
websockets.configure(conf);
expect(socketRegistry.register).not.toHaveBeenCalled();
});
it('should require the websocket module', function () {
websockets.configure(conf);
var expectedPath = path.join('components', 'button2', 'server', 'websockets', 'socket.js');
expect(global.requireWithContext.mostRecentCall.args[0]).toBe(expectedPath);
});
exports.configure = function(endpoint) {
var endpointConfig = globalConfig.config.endpoints[endpoint] || {};
if (!endpointConfig.handler)
throw 'Endpoint %' + endpoint + '% not found.';
var handler = endpointConfig.handler;
delete endpointConfig.handler;
try {
var endpointClass = require(handler);
}
catch(e) {
throw 'Endpoint handler`' + handler + '` not installed.';
}
endpointConfig.name = endpoint;
return Promise.resolve(endpointClass.configure && endpointClass.configure(endpointConfig, ui) || endpointConfig)
.then(function(_config) {
delete _config.name;
_config.handler = handler;
globalConfig.config.endpoints[endpoint] = _config;
})
.then(function() {
globalConfig.save();
});
}
exports.configure = function(registry) {
var registryConfig = globalConfig.config.registries[registry] || {},
RegistryClass;
if (!registryConfig.handler)
throw 'Registry %' + registry + '% not found.';
var handler = registryConfig.handler;
delete registryConfig.handler;
try {
RegistryClass = require(handler);
}
catch(e) {
throw 'Registry handler`' + handler + '` not installed.';
}
registryConfig.name = registry;
registryConfig.strictSSL = globalConfig.config.strictSSL;
return Promise.resolve(RegistryClass.configure && RegistryClass.configure(registryConfig, ui) || registryConfig)
.then(function(_config) {
delete _config.name;
delete _config.strictSSL;
_config.handler = handler;
globalConfig.config.registries[registry] = _config;
})
.then(function() {
globalConfig.save();
});
};
fs.readdirSync(routeDir).forEach(function (filename) {
console.log("Loading route " + filename);
if (~filename.indexOf('.js')) {
var routes = require(routeDir + '/' + filename);
routes.configure(app, passport);
}
});
exports.start = function(config) {
config.autoConnect = false;
var client = new irc.Client(config.server, config.nick, config);
client.match = function(pattern, callback) {
client.on('message', function(from, to, message) {
var matches;
var meta = {};
while ((matches = pattern.exec(message)) !== null) {
if (callback(from, to, message, matches, meta) === false) {
break;
}
}
});
};
client.on('error', function(message) {
console.error(message);
});
for (var i = 0, l = config.plugins.length; i < l; ++i) {
var name = config.plugins[i];
try {
var plugin = require('./plugins/' + name);
plugin.configure(client, config);
} catch (e) {
console.error('Error loading plugin', file + ':' + e.message);
}
}
client.connect();
};
function () {
eslint.configure(mockGenerator);
var files = projectBuilder.getIncludedFiles();
expect(files.length).toBe(2);
expect(files[0].to).toBe('.eslintignore');
expect(files[1].to).toBe('.eslintrc');
});
it( 'VANDIUM_PREVENT_EVAL = "false"', function() {
process.env.VANDIUM_PREVENT_EVAL = 'false';
prevent.configure();
expect( prevent.state ).to.eql( { 'eval': false } );
});
function () {
editorconfig.configure(mockGenerator);
var files = projectBuilder.getIncludedFiles();
expect(files.length).toBe(1);
expect(files[0].from).toBe('.editorconfig');
expect(files[0].to).toBe('.editorconfig');
});
it( 'VANDIUM_PREVENT_EVAL = "FALSE"', function() {
process.env.VANDIUM_PREVENT_EVAL = 'FALSE';
prevent.configure();
expect( eval.bind( null, 'var x = 5;' ) ).to.not.throw( 'security violation:' );
});
it( 'VANDIUM_PREVENT_EVAL = "TRUE"', function() {
process.env.VANDIUM_PREVENT_EVAL = 'TRUE';
prevent.configure();
expect( prevent.state ).to.eql( { 'eval': true } );
});
it('should register sockets from the component/server/websockets directory', function () {
websockets.configure(conf);
var expectedFolder = path.join('components', 'button2', 'server', 'websockets');
expect(util.walkSync).toHaveBeenCalled();
expect(util.walkSync.mostRecentCall.args[0]).toBe(expectedFolder);
});
it ('configuring works', () => {
const asTable25 = asTable.configure ({ maxTotalWidth: 25 }),
asTable25Delim = asTable25.configure ({ delimiter: ' | ' })
assert.notEqual (asTable25, asTable25Delim)
assert.equal (asTable25.maxTotalWidth, 25)
assert.equal (asTable25Delim.delimiter, ' | ')
})
function () {
var generator = mocks.buildGenerator();
generator.fs.write('.gitreview', ini.stringify(iniFile));
gerrit.init(generator);
gerrit.prompt(generator);
gerrit.configure(generator);
expectGerritFileContent(iniFile);
});
function () {
mockGenerator.fs.write('.gitignore', ['one', 'two'].join('\n'));
gitignore.init(mockGenerator);
gitignore.prompt(mockGenerator);
gitignore.configure(mockGenerator);
var files = projectBuilder.getIncludedFiles();
expect(files.length).toBe(1);
expect(files[0].to).toBe('.gitignore');
});
function () {
eslint.init(mockGenerator);
eslint.configure(mockGenerator);
var files = projectBuilder.getIncludedFiles();
var eslintRcRef = files[1];
expect(eslintRcRef.to).toBe('.eslintrc');
expect(yaml.safeLoad(eslintRcRef.content()))
.toEqual({extends: 'openstack'});
});
function () {
var ignoreSpy = spyOn(projectBuilder, 'ignoreFile');
var generator = mocks.buildGenerator();
structure.init(generator);
structure.prompt(generator);
structure.configure(generator);
expect(ignoreSpy).toHaveBeenCalledWith('./dist');
});
i18nConfig() {
i18n.configure({
locales:[`en`],
directory: `app/locales`,
objectNotation: true,
updateFiles: false,
api: {
'__': 't'
}
});
}
it ('array printing works', () => {
var testData = [['qwe', '123456789', 'zxcvbnm'],
['qwerty', '12', 'zxcvb'],
['💩wertyiop', '1234567', 'z']]
assert.equal (asTable (testData),
'qwe 123456789 zxcvbnm\n' +
'qwerty 12 zxcvb \n' +
'💩wertyiop 1234567 z ')
assert.equal (asTable.configure ({ maxTotalWidth: 22, delimiter: ' | ' }) (testData),
'qwe | 1234… | zxc…\n' +
'qwer… | 12 | zxc…\n' +
'💩wer… | 1234… | z ')
console.log (asTable.configure ({ maxTotalWidth: 22, delimiter: ' | ' }) (testData))
})
function () {
mockGenerator.fs.write('.eslintrc', JSON.stringify(mockEslintRc));
eslint.init(mockGenerator);
eslint.configure(mockGenerator);
var files = projectBuilder.getIncludedFiles();
var eslintRcRef = files[1];
var eslintContent = yaml.safeLoad(eslintRcRef.content());
expect(mockEslintRc).toEqual(eslintContent);
});
var registerCommand = function(filename, app) {
var name = path.basename(filename, path.extname(filename));
var commandDefinition = require(path.join(commandDirectory, name));
var command = app.command(name);
command.description(commandDefinition.description || 'Executes the "' + name + '" command');
command.action(commandDefinition.action || null);
if (commandDefinition.configure) {
commandDefinition.configure(command);
}
};
it ('right align works', () => {
var testData =
[ { foo: 1234.567, bar: 12 },
{ foo: '4.567'.bgMagenta.green, bar: 1234.456890 } ]
assert.equal (asTable.configure ({ right: true }) (testData),
' foo bar\n' +
'--------------------\n' +
'1234.567 12\n' +
' ' + '4.567'.bgMagenta.green + ' 1234.45689')
})
before(function(done) {
var config = {
typeName: 'log4js',
buffersize: 1,
url: process.env.ES_URL,
layout: {
type: 'logstash'
}
};
log4js.clearAppenders();
log4js.addAppender(log4jsElasticSearch.configure(config, null, done), 'unittest');
});
function () {
// No answers, non-interactive run.
var mockAnswers = {};
var generator = mocks.buildGenerator(null, mockAnswers);
generator.fs.delete('.gitreview');
gerrit.init(generator);
gerrit.prompt(generator);
gerrit.configure(generator);
expect(generator.fs.exists('.gitreview')).toBeFalsy();
});
function () {
// No answers, non-interactive run.
var mockAnswers = {};
var generator = mocks.buildGenerator(null, mockAnswers);
generator.fs.write('.gitreview', ini.stringify(iniFile));
// Set defaults
gerrit.init(generator);
gerrit.prompt(generator);
gerrit.configure(generator);
expect(generator.fs.exists('.gitreview')).toBeTruthy();
});
configureModule: function(moduleName, data, config){
if(moduleName in itIsNotAModule){
logger.info('Skipping not-a-module "' + moduleName + '"');
return;
}
var module = require(moduleName);
if(module.configure && typeof module.configure === 'function'){
module.configure(data, config.rootDir, config);
logger.info('Module "' + moduleName + '" configured');
}else{
logger.warn('Module "' + moduleName + '" doesn\'t have configure method. Skipping');
}
},
async function configure (appPath) {
const platform = os.platform()
switch (platform) {
case 'win32':
case 'darwin':
case 'linux':
const configurator = require(`./configure/${platform}`).default
return await configurator.configure(appPath)
default:
throw new Error(`Unsupported platform: ${platform}`)
}
}