autobench 0.0.1alpha1

data/lib/phantomas/core/formatter.js

@@ -0,0 +1,65 @@
+/**
+ * Results formatter
+ */
+var formatter = function(results, format) {
+	function render() {
+		switch(format) {
+			case 'json':
+				return formatJson();
+
+			case 'csv':
+				return formatCsv();
+
+			case 'plain':
+			default:
+				return formatPlain();
+		}
+	}
+
+	function formatJson() {
+		return JSON.stringify(results);
+	}
+
+	function formatCsv() {
+		var obj = results.metrics,
+			key,
+			keys = [],
+			values = [];
+
+		for (key in obj) {
+			keys.push(key);
+			values.push(obj[key]);
+		}
+
+		return keys.join(',') + "\n" + values.join(',');
+	}
+
+	function formatPlain() {
+		var res = '',
+			obj = results.metrics,
+			key;
+
+		// header
+		res += 'phantomas metrics for <' + results.url + '>:\n\n';
+
+		// metrics
+		for (key in obj) {
+			res += '* ' + key + ': ' + obj[key]+ '\n';
+		}
+
+		res += '\n';
+
+		// notices
+		results.notices.forEach(function(msg) {
+			res += '> ' + msg + "\n";
+		});
+
+		return res.trim();
+	}
+
+	// public interface
+	this.render = render;
+};
+
+exports.formatter = formatter;
+

data/lib/phantomas/core/helper.js

@@ -0,0 +1,64 @@
+/**
+ * phantomas helper code
+ *
+ * Executed in page window
+ */
+
+(function(window) {
+
+	// NodeRunner
+	var nodeRunner = function() {
+		// "Beep, Beep"
+	};
+
+	nodeRunner.prototype = {
+		// call callback for each child of node
+		walk: function(node, callback, depth) {
+			if (this.isSkipped(node)) {
+				return;
+			}
+
+			var childNode,
+				childNodes = node.childNodes || [];
+
+			depth = (depth || 1);
+
+			for (var n=0, len = childNodes.length; n < len; n++) {
+				childNode = childNodes[n];
+
+				// callback can return false to stop recursive
+				if (callback(childNode, depth) !== false) {
+					this.walk(childNode, callback, depth + 1);
+				}
+			}
+		},
+
+		// override this function when you create an object of class phantomas.nodeRunner
+		// by default only iterate over HTML elements
+		isSkipped: function(node) {
+			return !node || (node.nodeType !== Node.ELEMENT_NODE);
+		}
+	};
+
+	function getCaller() {
+		var caller = {};
+
+		try {
+			throw new Error('backtrace');
+		} catch(e) {
+			caller = (e.stackArray && e.stackArray[3]) || {};
+		}
+
+		return caller;
+	}
+
+	// create a scope
+	var phantomas = (window.phantomas = window.phantomas || {});
+
+	// exports
+	phantomas.nodeRunner = nodeRunner;
+	phantomas.getCaller = getCaller;
+
+	console.log('phantomas scope injected');
+
+})(window);

data/lib/phantomas/core/modules/requestsMonitor/requestsMonitor.js

@@ -0,0 +1,214 @@
+/**
+ * Simple HTTP requests monitor and analyzer
+ */
+exports.version = '1.1';
+
+exports.module = function(phantomas) {
+	// imports
+	var HTTP_STATUS_CODES = phantomas.require('http').STATUS_CODES,
+		parseUrl = phantomas.require('url').parse;
+
+	var requests = [];
+
+	// register metric
+	phantomas.setMetric('requests');
+	phantomas.setMetric('gzipRequests');
+	phantomas.setMetric('postRequests');
+	phantomas.setMetric('redirects');
+	phantomas.setMetric('notFound');
+	phantomas.setMetric('timeToFirstByte');
+	phantomas.setMetric('timeToLastByte');
+	phantomas.setMetric('bodySize'); // content only
+	phantomas.setMetric('contentLength'); // content only
+
+	// parse given URL to get protocol and domain
+	function parseEntryUrl(entry) {
+		var parsed;
+
+		if (entry.url.indexOf('data:') !== 0) {
+			// @see http://nodejs.org/api/url.html#url_url
+			parsed = parseUrl(entry.url) || {};
+
+			entry.protocol = parsed.protocol.replace(':', '');
+			entry.domain = parsed.hostname;
+			entry.query = parsed.query;
+
+			if (entry.protocol === 'https') {
+				entry.isSSL = true;
+			}
+		}
+		else {
+			// base64 encoded data
+			entry.domain = false;
+			entry.protocol = false;
+			entry.isBase64 = true;
+		}
+	}
+
+	// when the monitoring started?
+	var start;
+	phantomas.on('pageOpen', function(res) {
+		start = Date.now();
+	});
+
+	phantomas.on('onResourceRequested', function(res) {
+		// store current request data
+		var entry = requests[res.id] = {
+			id: res.id,
+			url: res.url,
+			method: res.method,
+			requestHeaders: {},
+			sendTime: res.time,
+			bodySize: 0
+		};
+
+		res.headers.forEach(function(header) {
+			entry.requestHeaders[header.name] = header.value;
+		});
+
+		parseEntryUrl(entry);
+
+		if (!entry.isBase64) {
+			phantomas.emit('send', entry, res);
+		}
+	});
+
+	phantomas.on('onResourceReceived', function(res) {
+		// current request data
+		var entry = requests[res.id];
+
+		switch(res.stage) {
+			// the beginning of response
+			case 'start':
+				entry.recvStartTime = res.time;
+				entry.timeToFirstByte = res.time - entry.sendTime;
+
+				// FIXME: buggy
+				// @see http://code.google.com/p/phantomjs/issues/detail?id=169
+				entry.bodySize += res.bodySize || 0;
+				break;
+
+			// the end of response
+			case 'end':
+				// timing
+				entry.recvEndTime = res.time;
+				entry.timeToLastByte = res.time - entry.sendTime;
+				entry.receiveTime = entry.recvEndTime - entry.recvStartTime;
+
+				// request method
+				switch(entry.method) {
+					case 'POST':
+						phantomas.incrMetric('postRequests');
+						break;
+				}
+
+				// HTTP code
+				entry.status = res.status || 200 /* for base64 data */;
+				entry.statusText = HTTP_STATUS_CODES[entry.status];
+
+				switch(entry.status) {
+					case 301:
+					case 302:
+						phantomas.incrMetric('redirects');
+						phantomas.addNotice(entry.url + ' is a redirect (HTTP ' + entry.status + ')');
+						break;
+
+					case 404:
+						phantomas.incrMetric('notFound');
+						phantomas.addNotice(entry.url + ' was not found (HTTP 404)');
+						break;
+				}
+
+				parseEntryUrl(entry);
+
+				// asset type
+				entry.type = 'other';
+
+				// analyze HTTP headers
+				entry.headers = {};
+				res.headers.forEach(function(header) {
+					entry.headers[header.name] = header.value;
+
+					switch (header.name.toLowerCase()) {
+						// TODO: why it's not gzipped?
+						// because: http://code.google.com/p/phantomjs/issues/detail?id=156
+						// should equal bodySize
+						case 'content-length':
+							entry.contentLength = parseInt(header.value, 10);
+							break;
+
+						// detect content type
+						case 'content-type':
+							// parse header value
+							var value = header.value.split(';').shift().toLowerCase();
+
+							switch(value) {
+								case 'text/html':
+									entry.type = 'html';
+									entry.isHTML = true;
+									break;
+
+								case 'text/css':
+									entry.type = 'css';
+									entry.isCSS = true;
+									break;
+
+								case 'application/x-javascript':
+								case 'application/javascript':
+								case 'text/javascript':
+									entry.type = 'js';
+									entry.isJS = true;
+									break;
+
+								case 'image/png':
+								case 'image/jpeg':
+								case 'image/gif':
+									entry.type = 'image';
+									entry.isImage = true;
+									break;
+
+								default:
+									phantomas.addNotice('Unknown content type found: ' + value);
+							}
+							break;
+
+						// detect content encoding
+						case 'content-encoding':
+							if (header.value === 'gzip') {
+								entry.gzip = true;
+							}
+							break;
+					}
+				});
+
+				// requests stats
+				if (!entry.isBase64) {
+					phantomas.incrMetric('requests');
+
+					phantomas.incrMetric('bodySize', entry.bodySize); // content only
+					phantomas.incrMetric('contentLength', entry.contentLength || entry.bodySize); // content only
+				}
+
+				if (entry.gzip) {
+					phantomas.incrMetric('gzipRequests');
+				}
+
+				// emit an event for other modules
+				phantomas.emit(entry.isBase64 ? 'base64recv' : 'recv' , entry, res);
+				//phantomas.log(entry);
+				break;
+		}
+	});
+
+	// TTFB / TTLB metrics
+	phantomas.on('recv', function(entry, res) {
+		// check the first request
+		if (entry.id === 1) {
+			phantomas.setMetric('timeToFirstByte', entry.timeToFirstByte);
+			phantomas.setMetric('timeToLastByte', entry.timeToLastByte);
+		}
+
+		// completion of the last HTTP request
+		phantomas.setMetric('httpTrafficCompleted', entry.recvEndTime - start);
+	});
+};

data/lib/phantomas/core/pads.js

@@ -0,0 +1,16 @@
+/**
+ * Helper functions for string formatting
+ */
+function lpad(str, len) {
+	var fill = new Array( Math.max(1, len - str.toString().length + 1) ).join(' ');
+	return fill + str;
+}
+
+function rpad(str, len) {
+	var fill = new Array( Math.max(1, len - str.toString().length + 1) ).join(' ');
+	return str + fill;
+}
+
+exports.lpad = lpad;
+exports.rpad = rpad;
+

data/lib/phantomas/core/phantomas.js

@@ -0,0 +1,418 @@
+/**
+ * phantomas main file
+ */
+
+var VERSION = '0.4.1';
+
+var getDefaultUserAgent = function() {
+	var version = phantom.version,
+		system = require('system'),
+		os = system.os;
+
+	return "phantomas/" + VERSION + " (PhantomJS/" + version.major + "." + version.minor + "." + version.patch + "; " + os.name + " " + os.architecture + ")";
+}
+
+var phantomas = function(params) {
+	// parse script CLI parameters
+	this.params = params;
+
+	// --url=http://example.com
+	this.url = this.params.url;
+
+	// --format=[csv|json]
+	this.resultsFormat = params.format || 'plain';
+
+	// --viewport=1280x1024
+	this.viewport = params.viewport || '1280x1024';
+
+	// --verbose
+	this.verboseMode = params.verbose === true;
+	
+	// --silent
+	this.silentMode = params.silent === true;
+
+	// --timeout (in seconds)
+	this.timeout = (params.timeout > 0 && parseInt(params.timeout, 10)) || 15;
+
+	// --modules=localStorage,cookies
+	this.modules = (params.modules) ? params.modules.split(',') : [];
+
+	// --user-agent=custom-agent
+	this.userAgent = params['user-agent'] || getDefaultUserAgent();
+
+	// setup the stuff
+	this.emitter = new (this.require('events').EventEmitter)();
+	this.emitter.setMaxListeners(200);
+
+	this.page = require('webpage').create();
+
+	// current HTTP requests counter
+	this.currentRequests = 0;
+
+	this.log('phantomas v' + VERSION);
+
+	// load core modules
+	this.addCoreModule('requestsMonitor');
+
+	// load 3rd party modules
+	var modules = (this.modules.length > 0) ? this.modules : this.listModules(),
+		self = this;
+
+	modules.forEach(function(moduleName) {
+		self.addModule(moduleName);
+	});
+};
+
+phantomas.version = VERSION;
+
+phantomas.prototype = {
+	metrics: {},
+	notices: [],
+
+	// simple version of jQuery.proxy
+	proxy: function(fn, scope) {
+		scope = scope || this;
+		return function () {
+			return fn.apply(scope, arguments);
+		};
+	},
+
+	// emit given event
+	emit: function(/* eventName, arg1, arg2, ... */) {
+		this.log('Event ' + arguments[0] + ' emitted');
+		this.emitter.emit.apply(this.emitter, arguments);
+	},
+
+	// bind to a given event
+	on: function(ev, fn) {
+		this.emitter.on(ev, fn);
+	},
+
+	once: function(ev, fn) {
+		this.emitter.once(ev, fn);
+	},
+
+	// returns "wrapped" version of phantomas object with public methods / fields only
+	getPublicWrapper: function() {
+		var self = this;
+
+		// modules API
+		return {
+			url: this.params.url,
+			params: this.params,
+
+			// events
+			on: function() {self.on.apply(self, arguments);},
+			once: function() {self.once.apply(self, arguments);},
+			emit: function() {self.emit.apply(self, arguments);},
+
+			// metrics
+			setMetric: function() {self.setMetric.apply(self, arguments);},
+			setMetricEvaluate: function() {self.setMetricEvaluate.apply(self, arguments);},
+			incrMetric: function() {self.incrMetric.apply(self, arguments);},
+
+			// debug
+			addNotice: function(msg) {self.addNotice(msg);},
+			log: function(msg) {self.log(msg);},
+			echo: function(msg) {self.echo(msg);},
+
+			// phantomJS
+			evaluate: function(fn) {return self.page.evaluate(fn);},
+			injectJs: function(src) {return self.page.injectJs(src);},
+			require: function(module) {return self.require(module);},
+			getPageContent: function() {return self.page.content;}
+		};
+	},
+
+	// initialize given core phantomas module
+	addCoreModule: function(name) {
+		var pkg = require('./modules/' + name + '/' + name);
+
+		// init a module
+		pkg.module(this.getPublicWrapper());
+
+		this.log('Core module ' + name + (pkg.version ? ' v' + pkg.version : '') + ' initialized');
+	},
+
+	// initialize given phantomas module
+	addModule: function(name) {
+		var pkg;
+		try {
+			pkg = require('./../modules/' + name + '/' + name);
+		}
+		catch (e) {
+			this.log('Unable to load module "' + name + '"!');
+			return false;
+		}
+
+		if (pkg.skip) {
+			this.log('Module ' + name + ' skipped!');
+			return false;
+		}
+
+		// init a module
+		pkg.module(this.getPublicWrapper());
+
+		this.log('Module ' + name + (pkg.version ? ' v' + pkg.version : '') + ' initialized');
+		return true;
+	},
+
+	// returns list of 3rd party modules located in modules directory
+	listModules: function() {
+		this.log('Getting the list of all modules...');
+
+		var fs = require('fs'),
+			modulesDir = fs.workingDirectory + '/modules',
+			ls = fs.list(modulesDir) || [],
+			modules = [];
+
+		ls.forEach(function(entry) {
+			if (fs.isFile(modulesDir + '/' + entry + '/' + entry + '.js')) {
+				modules.push(entry);
+			}
+		});
+
+		return modules;
+	},
+ 
+	// runs phantomas
+	run: function(callback) {
+
+		// check required params
+		if (!this.url) {
+			throw '--url argument must be provided!';
+		}
+
+		// to be called by tearDown
+		this.onDoneCallback = callback;
+
+		this.start = Date.now();
+
+		// setup viewport
+		var parsedViewport = this.viewport.split('x');
+
+		if (parsedViewport.length === 2) {
+			this.page.viewportSize = {
+				height: parseInt(parsedViewport[0], 10) || 1280,
+				width: parseInt(parsedViewport[1], 10) || 1024
+			};
+		}
+
+		// setup user agent
+		if (this.userAgent) {
+			this.page.settings.userAgent = this.userAgent;
+		}
+
+		// print out debug messages
+		this.log('Opening <' + this.url + '>...');
+		this.log('Using ' + this.page.settings.userAgent + ' as user agent');
+		this.log('Viewport set to ' + this.page.viewportSize.height + 'x' + this.page.viewportSize.width);
+
+		// bind basic events
+		this.page.onInitialized = this.proxy(this.onInitialized);
+		this.page.onLoadStarted = this.proxy(this.onLoadStarted);
+		this.page.onLoadFinished = this.proxy(this.onLoadFinished);
+		this.page.onResourceRequested = this.proxy(this.onResourceRequested);
+		this.page.onResourceReceived = this.proxy(this.onResourceReceived);
+
+		// debug
+		this.page.onAlert = this.proxy(this.onAlert);
+		this.page.onConsoleMessage = this.proxy(this.onConsoleMessage);
+
+		// observe HTTP requests
+		// finish when the last request is completed
+		
+		// update HTTP requests counter
+		this.on('send', this.proxy(function(entry) {
+			this.currentRequests++;
+		}));
+	
+		this.on('recv', this.proxy(function(entry) {
+			this.currentRequests--;
+
+			this.enqueueReport();
+		}));
+
+		// last time changes?
+		this.emit('pageBeforeOpen', this.page);
+
+		// open the page
+		this.page.open(this.url);
+
+		this.emit('pageOpen');
+
+		// fallback - always timeout after TIMEOUT seconds
+		this.log('Run timeout set to ' + this.timeout + ' s');
+		setTimeout(this.proxy(function() {
+			this.log('Timeout of ' + this.timeout + ' s was reached!');
+			this.report();
+		}), this.timeout * 1000);
+	},
+
+	/**
+	 * Wait a second before finishing the monitoring (i.e. report generation)
+	 *
+	 * This one is called when response is received. Previously scheduled reporting is removed and the new is created.
+	 */
+	enqueueReport: function() {
+		clearTimeout(this.lastRequestTimeout);
+
+		if (this.currentRequests < 1) {
+			this.lastRequestTimeout = setTimeout(this.proxy(this.report), 1000);
+		}
+	},
+
+	// called when all HTTP requests are completed
+	report: function() {
+		this.emit('report');
+
+		var time = Date.now() - this.start;
+		this.log('phantomas work done in ' + time + ' ms');
+
+		// format results
+		var results = {
+			url: this.url,
+			metrics: this.metrics,
+			notices: this.notices
+		};
+
+		this.emit('results', results);
+
+		// count all metrics
+		var metricsCount = 0,
+			i;
+
+		for (i in this.metrics) {
+			metricsCount++;
+		}
+
+		this.log('Formatting results (' + this.resultsFormat + ') with ' + metricsCount+ ' metric(s)...');
+
+		// render results
+		var formatter = require('./formatter').formatter,
+			renderer = new formatter(results, this.resultsFormat);
+
+		this.echo(renderer.render());
+		this.tearDown(0);
+	},
+
+	tearDown: function(exitCode) {
+		exitCode = exitCode || 0;
+
+		if (exitCode > 0) {
+			this.log('Exiting with code #' + exitCode);
+		}
+
+		this.page.release();
+
+		// call function provided to run() method
+		if (typeof this.onDoneCallback === 'function') {
+			this.onDoneCallback();
+		}
+		else {
+			phantom.exit(exitCode);
+		}
+	},
+
+	// core events
+	onInitialized: function() {
+		// add helper tools into window.phantomas "namespace"
+		this.page.injectJs('./core/helper.js');
+
+		this.log('Page object initialized');
+		this.emit('init');
+	},
+
+	onLoadStarted: function() {
+		this.log('Page loading started');
+		this.emit('loadStarted');
+	},
+
+	onResourceRequested: function(res) {
+		this.emit('onResourceRequested', res);
+		//this.log(JSON.stringify(res));
+	},
+
+	onResourceReceived: function(res) {
+		this.emit('onResourceReceived', res);
+		//this.log(JSON.stringify(res));
+	},
+
+	onLoadFinished: function(status) {
+		// trigger this only once
+		if (this.onLoadFinishedEmitted) {
+			return;
+		}
+		this.onLoadFinishedEmitted = true;
+
+		// we're done
+		this.log('Page loading finished ("' + status + '")');
+
+		switch(status) {
+			case 'success':
+				this.emit('loadFinished', status);
+				this.enqueueReport();
+				break;
+
+			default:
+				this.emit('loadFailed', status);
+				this.tearDown(2);
+				break;
+		}
+	},
+
+	// debug
+	onAlert: function(msg) {
+		this.log('Alert: ' + msg);
+		this.emit('alert', msg);
+	},
+
+	onConsoleMessage: function(msg) {
+		this.log('console.log: ' + msg);
+		this.emit('consoleLog', msg);
+	},
+
+	// metrics reporting
+	setMetric: function(name, value) {
+		this.metrics[name] = (typeof value !== 'undefined') ? value : 0;
+	},
+
+	setMetricEvaluate: function(name, fn) {
+		this.setMetric(name, this.page.evaluate(fn));
+	},
+
+	// increements given metric by given number (default is one)
+	incrMetric: function(name, incr /* =1 */) {
+		this.metrics[name] = (this.metrics[name] || 0) + (incr || 1);
+	},
+
+	// adds a notice that will be emitted after results
+	addNotice: function(msg) {
+		this.notices.push(msg || '');
+	},
+
+	// add log message
+	// will be printed out only when --verbose
+	log: function(msg) {
+		if (this.verboseMode) {
+			msg = (typeof msg === 'object') ? JSON.stringify(msg) : msg;
+
+			this.echo('> ' + msg);
+		}
+	},
+
+	// console.log wrapper obeying --silent mode
+	echo: function(msg) {
+		if (!this.silentMode) {
+			console.log(msg);
+		}
+	},
+
+	// require CommonJS module from lib/modules
+	require: function(module) {
+		return require('../lib/modules/' + module);
+	}
+};
+
+exports.phantomas = phantomas;
+