2010-10-24 11:07:00 +08:00
|
|
|
require.paths.unshift(__dirname + '/../lib/');
|
2011-02-24 09:50:43 +08:00
|
|
|
//make assert a global...
|
|
|
|
assert = require('assert');
|
2010-10-24 11:07:00 +08:00
|
|
|
|
2011-02-24 09:50:43 +08:00
|
|
|
var EventEmitter = require('events').EventEmitter;
|
|
|
|
var sys = require('sys');
|
|
|
|
var BufferList = require(__dirname+'/buffer-list')
|
2010-11-04 05:47:26 +08:00
|
|
|
|
2011-02-24 09:50:43 +08:00
|
|
|
var Connection = require('connection');
|
2010-10-25 14:30:14 +08:00
|
|
|
var args = require(__dirname + '/cli');
|
2010-10-24 11:07:00 +08:00
|
|
|
|
2011-03-04 02:21:43 +08:00
|
|
|
Client = require(__dirname + '/../lib').Client;
|
2011-02-23 12:48:51 +08:00
|
|
|
|
2010-12-19 17:41:11 +08:00
|
|
|
process.on('uncaughtException', function(d) {
|
|
|
|
if ('stack' in d && 'message' in d) {
|
|
|
|
console.log("Message: " + d.message);
|
|
|
|
console.log(d.stack);
|
|
|
|
} else {
|
|
|
|
console.log(d);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2010-10-24 11:07:00 +08:00
|
|
|
assert.same = function(actual, expected) {
|
|
|
|
for(var key in expected) {
|
|
|
|
assert.equal(actual[key], expected[key]);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2011-05-20 09:04:48 +08:00
|
|
|
assert.emits = function(item, eventName, callback, message) {
|
2010-10-24 11:07:00 +08:00
|
|
|
var called = false;
|
|
|
|
var id = setTimeout(function() {
|
2010-10-25 12:18:23 +08:00
|
|
|
test("Should have called " + eventName, function() {
|
2011-05-20 09:04:48 +08:00
|
|
|
assert.ok(called, message || "Expected '" + eventName + "' to be called.")
|
2010-10-25 12:18:23 +08:00
|
|
|
});
|
2011-02-23 09:32:18 +08:00
|
|
|
},2000);
|
2010-10-24 11:07:00 +08:00
|
|
|
|
|
|
|
item.once(eventName, function() {
|
|
|
|
called = true;
|
|
|
|
clearTimeout(id);
|
|
|
|
assert.ok(true);
|
|
|
|
if(callback) {
|
|
|
|
callback.apply(item, arguments);
|
|
|
|
}
|
|
|
|
});
|
2010-11-01 13:25:03 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
assert.UTCDate = function(actual, year, month, day, hours, min, sec, milisecond) {
|
|
|
|
var actualYear = actual.getUTCFullYear();
|
|
|
|
assert.equal(actualYear, year, "expected year " + year + " but got " + actualYear);
|
|
|
|
|
2011-08-13 00:17:43 +08:00
|
|
|
var actualMonth = actual.getUTCMonth();
|
|
|
|
assert.equal(actualMonth, month, "expected month " + month + " but got " + actualMonth);
|
|
|
|
|
2010-11-01 13:25:03 +08:00
|
|
|
var actualDate = actual.getUTCDate();
|
|
|
|
assert.equal(actualDate, day, "expected day " + day + " but got " + actualDate);
|
|
|
|
|
|
|
|
var actualHours = actual.getUTCHours();
|
|
|
|
assert.equal(actualHours, hours, "expected hours " + hours + " but got " + actualHours);
|
|
|
|
|
|
|
|
var actualMin = actual.getUTCMinutes();
|
|
|
|
assert.equal(actualMin, min, "expected min " + min + " but got " + actualMin);
|
|
|
|
|
|
|
|
var actualSec = actual.getUTCSeconds();
|
|
|
|
assert.equal(actualSec, sec, "expected sec " + sec + " but got " + actualSec);
|
2010-10-24 11:07:00 +08:00
|
|
|
|
2010-11-01 13:25:03 +08:00
|
|
|
var actualMili = actual.getUTCMilliseconds();
|
|
|
|
assert.equal(actualMili, milisecond, "expected milisecond " + milisecond + " but got " + actualMili);
|
2010-10-24 11:07:00 +08:00
|
|
|
};
|
|
|
|
|
2011-01-15 05:18:56 +08:00
|
|
|
var spit = function(actual, expected) {
|
|
|
|
console.log("");
|
|
|
|
console.log("actual " + sys.inspect(actual));
|
|
|
|
console.log("expect " + sys.inspect(expected));
|
|
|
|
console.log("");
|
|
|
|
}
|
|
|
|
|
2010-10-24 11:07:00 +08:00
|
|
|
assert.equalBuffers = function(actual, expected) {
|
|
|
|
if(actual.length != expected.length) {
|
2011-01-15 05:18:56 +08:00
|
|
|
spit(actual, expected)
|
2010-10-24 11:07:00 +08:00
|
|
|
assert.equal(actual.length, expected.length);
|
|
|
|
}
|
|
|
|
for(var i = 0; i < actual.length; i++) {
|
|
|
|
if(actual[i] != expected[i]) {
|
2011-01-15 05:18:56 +08:00
|
|
|
spit(actual, expected)
|
2010-10-24 11:07:00 +08:00
|
|
|
}
|
|
|
|
assert.equal(actual[i],expected[i]);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
assert.empty = function(actual) {
|
|
|
|
assert.length(actual, 0);
|
|
|
|
};
|
|
|
|
|
2011-01-22 05:13:58 +08:00
|
|
|
assert.success = function(callback) {
|
2011-01-22 06:53:17 +08:00
|
|
|
return assert.calls(function(err, arg) {
|
2011-01-22 05:13:58 +08:00
|
|
|
assert.isNull(err);
|
|
|
|
callback(arg);
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2011-02-25 11:50:17 +08:00
|
|
|
assert.throws = function(offender) {
|
|
|
|
try {
|
|
|
|
offender();
|
|
|
|
} catch (e) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
assert.ok(false, "Expected " + offender + " to throw exception");
|
|
|
|
}
|
2010-10-24 11:07:00 +08:00
|
|
|
|
|
|
|
assert.length = function(actual, expectedLength) {
|
|
|
|
assert.equal(actual.length, expectedLength);
|
|
|
|
};
|
|
|
|
|
2010-12-10 10:50:19 +08:00
|
|
|
var expect = function(callback, timeout) {
|
2010-12-03 04:43:17 +08:00
|
|
|
var executed = false;
|
2010-12-03 07:48:39 +08:00
|
|
|
var id = setTimeout(function() {
|
2010-12-14 07:20:51 +08:00
|
|
|
assert.ok(executed, "Expected execution of funtion to be fired");
|
2010-12-11 07:32:34 +08:00
|
|
|
}, timeout || 2000)
|
2010-12-03 04:43:17 +08:00
|
|
|
|
|
|
|
return function(err, queryResult) {
|
2010-12-03 07:48:39 +08:00
|
|
|
clearTimeout(id);
|
|
|
|
assert.ok(true);
|
2010-12-03 04:43:17 +08:00
|
|
|
callback.apply(this, arguments)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert.calls = expect;
|
|
|
|
|
2010-12-10 10:53:59 +08:00
|
|
|
assert.isNull = function(item, message) {
|
|
|
|
message = message || "expected " + item + " to be null";
|
|
|
|
assert.ok(item === null, message);
|
|
|
|
};
|
|
|
|
|
2010-10-24 11:07:00 +08:00
|
|
|
test = function(name, action) {
|
2010-12-10 10:50:19 +08:00
|
|
|
test.testCount ++;
|
2010-12-20 04:46:43 +08:00
|
|
|
if(args.verbose) {
|
|
|
|
console.log(name);
|
|
|
|
}
|
2010-12-10 10:50:19 +08:00
|
|
|
var result = action();
|
|
|
|
if(result === false) {
|
|
|
|
test.ignored.push(name);
|
2010-12-20 04:46:43 +08:00
|
|
|
if(!args.verbose) {
|
|
|
|
process.stdout.write('?');
|
|
|
|
}
|
2010-12-10 10:50:19 +08:00
|
|
|
}else{
|
2010-12-20 04:46:43 +08:00
|
|
|
if(!args.verbose) {
|
|
|
|
process.stdout.write('.');
|
|
|
|
}
|
2010-10-24 11:07:00 +08:00
|
|
|
}
|
|
|
|
};
|
2010-10-25 14:30:14 +08:00
|
|
|
|
2010-12-15 08:50:18 +08:00
|
|
|
//print out the filename
|
|
|
|
process.stdout.write(require('path').basename(process.argv[1]));
|
2010-12-20 04:46:43 +08:00
|
|
|
//print a new line since we'll be printing test names
|
|
|
|
if(args.verbose) {
|
|
|
|
console.log();
|
|
|
|
}
|
2010-10-24 11:07:00 +08:00
|
|
|
test.testCount = test.testCount || 0;
|
|
|
|
test.ignored = test.ignored || [];
|
|
|
|
test.errors = test.errors || [];
|
|
|
|
|
|
|
|
process.on('exit', function() {
|
|
|
|
console.log('');
|
2010-12-15 08:50:18 +08:00
|
|
|
if(test.ignored.length || test.errors.length) {
|
|
|
|
test.ignored.forEach(function(name) {
|
|
|
|
console.log("Ignored: " + name);
|
|
|
|
});
|
|
|
|
test.errors.forEach(function(error) {
|
|
|
|
console.log("Error: " + error.name);
|
|
|
|
});
|
|
|
|
console.log('');
|
|
|
|
}
|
2010-10-24 11:07:00 +08:00
|
|
|
test.errors.forEach(function(error) {
|
|
|
|
throw error.e;
|
|
|
|
});
|
|
|
|
});
|
2010-12-15 08:50:18 +08:00
|
|
|
|
|
|
|
process.on('uncaughtException', function(err) {
|
|
|
|
console.error("\n %s", err.stack || err.toString())
|
|
|
|
//causes xargs to abort right away
|
|
|
|
process.exit(255);
|
|
|
|
});
|
|
|
|
|
2010-12-14 07:20:51 +08:00
|
|
|
var count = 0;
|
|
|
|
|
|
|
|
var Sink = function(expected, timeout, callback) {
|
|
|
|
var defaultTimeout = 1000;
|
|
|
|
if(typeof timeout == 'function') {
|
|
|
|
callback = timeout;
|
|
|
|
timeout = defaultTimeout;
|
|
|
|
}
|
|
|
|
timeout = timeout || defaultTimeout;
|
|
|
|
var internalCount = 0;
|
|
|
|
var kill = function() {
|
|
|
|
assert.ok(false, "Did not reach expected " + expected + " with an idle timeout of " + timeout);
|
|
|
|
}
|
|
|
|
var killTimeout = setTimeout(kill, timeout);
|
|
|
|
return {
|
|
|
|
add: function(count) {
|
|
|
|
count = count || 1;
|
|
|
|
internalCount += count;
|
|
|
|
clearTimeout(killTimeout)
|
|
|
|
if(internalCount < expected) {
|
|
|
|
killTimeout = setTimeout(kill, timeout)
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
assert.equal(internalCount, expected);
|
|
|
|
callback();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-10-25 14:30:14 +08:00
|
|
|
|
|
|
|
module.exports = {
|
2010-12-14 07:20:51 +08:00
|
|
|
args: args,
|
|
|
|
Sink: Sink,
|
2010-12-15 09:23:01 +08:00
|
|
|
pg: require('index'),
|
2010-12-14 07:20:51 +08:00
|
|
|
connectionString: function() {
|
|
|
|
return "pg"+(count++)+"://"+args.user+":"+args.password+"@"+args.host+":"+args.port+"/"+args.database;
|
2011-02-24 09:50:43 +08:00
|
|
|
},
|
|
|
|
sys: sys,
|
|
|
|
Client: Client
|
2010-10-25 14:30:14 +08:00
|
|
|
};
|
2010-12-14 07:20:51 +08:00
|
|
|
|
|
|
|
|