testSetupWithBrowser: function(){
var ts = new testSession({},{"browser" : "firefox"},null);
ts.setup(function() {
A.areEqual(ts.driverName, "selenium" ,"if browser is passed, driver name should be 'selenium'") ;
A.isNotNull(ts.driver, "driver object should be created")
});
}
testSetupWithController: function(){
var ts = new testSession({},{"controller" : "SuperIntelligentController"},null);
ts.setup(function() {
A.areEqual(ts.driverName, "selenium" ,"For any custom controller driver name should be 'selenium'") ;
A.isNotNull(ts.driver, "driver object should be created")
});
}
testSetupWithPage: function(){
var ts = new testSession({},{"params":{"page" : "http://www.yahoo.com"}},null);
ts.setup(function() {
A.areEqual(ts.driverName, "selenium" ,"if page is passed, driver name should be 'selenium'") ;
A.isNotNull(ts.driver, "driver object should be created")
});
}
testSetupWithAllNullParams: function(){
var ts = new testSession({},{},null);
ts.setup(function() {
A.areEqual(ts.driverName, "nodejs" ,"default driver name if all params are null, should be 'nodejs'") ;
A.isNotNull(ts.driver, "driver object should be created")
});
}
module.exports = function(app)
{
for (routesGroupName in routes)
{
var controller = require('../controllers/' + routesGroupName)
, methodGroupedRoutes = routes[routesGroupName];
controllerInstance = new controller.class();
if (controller.setup)
{
controller.setup(app, routes[routesGroupName]);
}
for (method in methodGroupedRoutes)
{
var methodRoutes = methodGroupedRoutes[method];
for (action in methodRoutes)
{
var route = methodRoutes[action];
app[method].call(app, route, (function(controllerInstance, action)
{
return function(req, res)
{
res.cookie('iacv', app.locals.version, { maxAge: 1000*60*60*24*365 });
controllerInstance[action].apply(app, arguments);
}
})(controllerInstance, action));
}
}
}
}
verifyCirconusAPI() {
console.log(chalk.blue(this.marker));
console.log("Verify Circonus API access");
const self = this;
api.setup(cosi.api_key, cosi.api_app, cosi.api_url);
api.get("/account/current", null, (code, err, account) => {
if (err) {
self.emit("error", err);
return;
}
if (code !== 200) {
self.emit("error", new Error(`verifyAPI - API return code: ${code} ${err} ${account}`));
}
console.log(chalk.green("API key verified"), "for account", account.name, account.description === null ? "" : `- ${account.description}`);
let accountUrl = account._ui_base_url || "your_account_url";
if (accountUrl.substr(-1) === "/") {
accountUrl = accountUrl.substr(0, accountUrl.length - 1);
}
self.regConfig.account = {
name: account.name,
uiUrl: accountUrl
};
self.emit("verify.api.done");
});
}
var AppBase = function (port, setupIoServer) {
var path = require('path');
var express = require('express');
var app = express.createServer();
var scriptFolder = (setupIoServer ? 'user' : 'watcher');
app.configure(function () {
app.use(
'/',
express.static(path.join(__dirname, '..', '..', 'www'))
);
app.use(
'/scripts/',
express.static(path.join(__dirname, '..', 'www-scripts', scriptFolder))
);
});
// Setup the frontend with specified port (default port 80)
app.listen(port || 80);
// Setup ioServer if specified
if (setupIoServer === true) {
var io = require('socket.io').listen(app);
var IoServer = require(path.join(__dirname, 'server'));
var ioServer = new IoServer(io);
ioServer.setup();
}
};
var init = function(configfile){
var HOSTNAME = process.env.HOSTNAME;
var PORT = process.env.PORT || 3000;
var tasklists = [];
var tacticsHandler = new TacticsHandler([]);
var strategyManager = new StrategyManager([]);
var task = new Task(100, 1);
task.start();
task.on('report', function(count){
// console.log('exec : ' + count);
});
var update = function(func){
task.add(function(){
func();
update(func);
});
};
config.setup(configfile, tasklists, tacticsHandler, strategyManager);
tasklists.push(function running_strategy(next){
update( function(){
strategyManager.heartbeat();
});
});
return tasklists;
}
examples.forEach( function( example ){
console.log( '\n EXAMPLE ' + example + '\n' );
var service = require( example + '/service' );
service.setup();
service.start( function(){
var proc = child.spawn( './node_modules/ciao/bin/ciao', [ example + '/scripts' ] );
proc.stdout.pipe( process.stdout );
proc.stderr.pipe( process.stderr );
proc.on( 'exit', function( code ){
if( code ){
exitCode = code;
}
service.stop();
service.teardown();
});
});
});
[''].map(function(controllerName) { // Examples: ['api', 'authorization', 'users', 'tests']
if (controllerName === '') {
controllerName = 'index'; // Default controller
}
var controller = require('./routes/' + controllerName);
controller.setup(app, program);
});
update(cb) { //eslint-disable-line consistent-return
assert.strictEqual(typeof cb, "function", "cb must be a callback function");
if (!this.verifyConfig(true)) {
return cb(new Error("Invalid configuration"));
}
const self = this;
api.setup(cosi.api_key, cosi.api_app, cosi.api_url);
api.put(this._cid, this, (code, errAPI, result) => {
if (errAPI) {
return cb(errAPI, result);
}
if (code !== 200) {
const errResp = new Error();
errResp.code = code;
errResp.message = "UNEXPECTED_API_RETURN";
errResp.details = result;
return cb(errResp);
}
self._init(result);
return cb(null, result);
});
}
testSetupForDefaultTestHost: function(){
var ts = new testSession({"defaultTestHost":"SuperHost"},{},null);
ts.setup(function() {
A.isNotNull(ts.driver, "driver object should be created");
A.areEqual(ts.testParams.page,"SuperHost","page should be 'SuperHost'");
});
}
} ).forEach( function( file ) {
console.log( "Setting up controller", file.green );
var controller = require( "./" + file );
var name = file.substring( 0, file.length - path.extname(file).length );
module.exports[name] = controller.setup( app );
} );
testSetupWithSessionID: function(){
var ts = new testSession({},{},1);
ts.setup(function() {
A.areEqual(ts.driverName, "selenium" ,"if sessionID is passed, driver name should be 'selenium'") ;
A.isNotNull(ts.driver, "driver object should be created");
A.areEqual(ts.driver.sessionId,1,"SessionID should be '1'");
});
}
controllerFiles.forEach(function(ctrlFile) {
if (ctrlFile.indexOf('-controller.js') === - 1) {
return;
}
ctrlFile = ctrlFile.replace('.js', '');
var controller = require('../controllers/' + ctrlFile);
var instance = new controller();
instance.setup();
});
function setupTestDb(next){
var dbOptions = {
path: path + 'models',
database: config.database,
debug: false
};
database.setup(dbOptions, null, function(err){
next(err, database);
});
}
fs.readdirSync('./app').forEach(function (file) {
// check file is javascript file
if (file.match(/\.js$/)) {
var api = require('./app/' + file);
if (typeof api.setup === 'function') {
console.log('.setup() in : ' + file);
api.setup(router);
}
}
});
_.each(this._links, function (link, name) {
try {
var per = require("./provider/" + name);
per.setup(name, link)
self._pers.push(per);
}
catch(e) {
//
console.log(e);
}
})
fs.readdirSync(dir).each(function(i, file){
// Dynamically load all the setup files from the setup folder
if (file.getExtension() === "js") {
var filepath = dir + file;
if (fs.existsSync(filepath)) {
console.log("__Setup ", filepath);
var component = require("./" + filepath.getFileName());
if (component.hasOwnProperty("setup")) {
component.setup(app);
}
}
}
});
it('should create sample files', () => {
disableLog()
lambda.setup(program)
enableLog()
const libPath = path.join(__dirname, '..', 'lib')
targetFiles.forEach((targetFile) => {
const boilerplateFile = path.join(libPath, `${targetFile}.example`)
assert.equal(
fs.readFileSync(targetFile).toString(),
fs.readFileSync(boilerplateFile).toString(),
targetFile
)
})
})
suite.test('Infects 1% of 5,000 users on 50 edges ± 0.1%', function (t) {
var users = 5000;
var edges = 50;
var targetPercentage = .01;
var e = .001;
var targetUsers = Math.floor(users * targetPercentage);
var min = users * (targetPercentage - e);
var max = users * (targetPercentage + e);
state.setup(app, users, edges);
app.limitedInfection(targetUsers, '2.0');
var betaUsers = app.model.Users.select({version: '2.0'});
t.assert(betaUsers.length > min && betaUsers.length < max);
});
gPloy.isRunning(function(err, running) {
if (err) {
console.log(" Error getting the worker status".red);
console.log(err.message.red);
console.log(err.stack);
process.exit(-1);
}
if (running === false) {
gPloy.setup();
console.log(" gploy isnt running in the moment".green);
gPloy.startInBackground();
} else {
console.log(" gploy is running in the moment".yellow);
}
});
driver.connect(function() {
// Wrap the marionette connection with a client that we can pass
// to our plugin.
var client = new Marionette.Client(driver);
// Make a bootwatcher to tell us when we're done booting.
BootWatcher.setup(client, function(err, bootwatcher) {
function onBoot(evt) {
bootwatcher.removeListener(BootWatcher.EventType.BOOT, onBoot);
demo(client, childProcess);
}
bootwatcher.addListener(BootWatcher.EventType.BOOT, onBoot);
client.startSession(function() {
bootwatcher.start();
});
});
});
it('shows setup as TBD', function(done) {
var IndexActions = require(__path__);
var Reflux = require('reflux');
Reflux.createStore({
listenables: IndexActions,
onSetupCompleted: function() {
should.fail('Expected the setup to fail.');
},
onSetupFailed: function(err) {
expect(err).toBe('TBD');
done();
}
});
IndexActions.setup();
});
fs.readdirSync(v1).forEach(function(file) {
var route = '/v1/' + file.replace('.js', '');
var service = require(path.join(v1,file));
if (typeof service === 'object') {
console.log('mounting', file, 'to', route);
var routeInfo = {
endpoint: route,
name: service.name,
schema: service.schema(JSON.parse(JSON.stringify(generalSchema)))
};
v1Routes.push(routeInfo);
app.get(route, function(req, ret) {
ret.send(routeInfo);
});
app.use(route, service.setup(settings, sanitizer(routeInfo.schema)))
}
});
testParallelExecutionWithCodeNonZeroWorkers : function(test) {
var CliRunner = require('../../../' + BASE_PATH + '/../lib/runner/cli/clirunner.js');
var runner = new CliRunner({
config : './extra/parallelism-count.json'
});
test.expect(2);
var originalExit = process.exit;
process.exit = function(code) {
test.equals(code, 1);
test.done();
process.exit = originalExit;
};
runner.setup({}, function(output, code) {
test.equals(code, 1);
});
},
var setup = function*(yamlFile, keepOpenBrowser) {
var options = yaml.load(yamlFile);
if(!options.pocci || !options.pocci.services) {
return;
}
var services = options.pocci.services;
console.log('*** Start Selenium Webdriver...');
yield initBrowser();
var browser = module.exports.browser;
if(services.indexOf('user') > -1) {
console.log('*** Add users...');
yield user.setup(browser, options);
}
if(services.indexOf('gitlab') > -1) {
console.log('*** Setup gitlab...');
yield gitlab.setup(browser, options);
}
var modules = fs.readdirSync(__dirname);
for(var i = 0; i < modules.length; i++) {
var fileName = modules[i];
if(fileName.match(/\.js$/) && fileName !== 'setup.js' &&
fileName !== 'user.js' && fileName !== 'gitlab.js') {
var serviceName = fileName.split('.')[0];
if(services.indexOf(serviceName) > -1) {
var m = require('pocci/' + fileName);
if(m.setup) {
console.log('*** Setup ' + serviceName + '...');
yield m.setup(browser, options);
}
}
}
}
if(!keepOpenBrowser) {
console.log('*** Closing browser...');
yield browser.end();
}
};
/**
* Gets called once we have a child process booted with Firefox OS.
* @param {Marionette.Client} client Marionette client to use.
* @param {ChildProcess} childProcess Child process running b2g.
*/
function demo(client, childProcess) {
// Initialize the Apps plugin!
Apps.setup(client, function(err, apps) {
// Ask for all of the apps.
var req = apps.mgmt.getAll();
req.onsuccess = function(evt) {
// Prove that we got them by logging them!
evt.target.result.forEach(function(app) {
console.log(app.origin);
// If this is the calendar app, try launching it!
if (app.origin === CALENDAR_URL) {
app.launch();
}
});
setTimeout(childProcess.kill.bind(childProcess), 5000);
};
});
}
_.forEach(clist, function(cfile){
var parsed = path.parse(cfile);
var module = require(cfile);
if(typeof module === 'object')
{
if(module.init)
module.init();
if(module.setup)
module.setup();
if(module.main)
module.main();
}
if(typeof cb === 'function')
cb(module, parsed, cfile);
if(pbar)
pbar.tick();
});
it('should use existing sample files', () => {
program.eventFile = 'newEvent.json'
program.contextFile = 'newContext.json'
disableLog()
lambda.setup(program)
enableLog()
assert.equal(fs.readFileSync('newContext.json').toString(), '{"FOO"="bar"\n"BAZ"="bing"\n}')
assert.equal(fs.readFileSync('newEvent.json').toString(), '{"FOO"="bar"}')
const libPath = path.join(__dirname, '..', 'lib')
filesCreatedBySetup.forEach((targetFile) => {
const boilerplateFile = path.join(libPath, `${targetFile}.example`)
assert.equal(
fs.readFileSync(targetFile).toString(),
fs.readFileSync(boilerplateFile).toString(),
targetFile
)
})
})