You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
11 KiB
301 lines
11 KiB
var redis = require("./redis"),
|
|
client = redis.createClient(),
|
|
assert = require("assert"),
|
|
tests = {};
|
|
|
|
redis.debug_mode = false;
|
|
|
|
function require_number(expected, label) {
|
|
return function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(expected, results, label + " " + expected + " !== " + results);
|
|
assert.strictEqual(typeof results, "number", label);
|
|
return true;
|
|
};
|
|
}
|
|
|
|
function require_number_any(label) {
|
|
return function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(typeof results, "number", label + " " + results + " is not a number");
|
|
return true;
|
|
};
|
|
}
|
|
|
|
function require_number_pos(label) {
|
|
return function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(true, (results > 0), label + " " + results + " is not a positive number");
|
|
return true;
|
|
};
|
|
}
|
|
|
|
function require_string(str, label) {
|
|
return function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.equal(str, results, label + " " + str + " does not match " + results);
|
|
return true;
|
|
};
|
|
}
|
|
|
|
function require_error(label) {
|
|
return function (err, results) {
|
|
assert.notEqual(err, null, label + " err is null, but an error is expected here.");
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function last(name, fn) {
|
|
return function (err, results) {
|
|
fn(err, results);
|
|
next(name);
|
|
};
|
|
}
|
|
|
|
function next(name) {
|
|
console.log(name + " passed " + (Date.now() - cur_start) + " ms");
|
|
run_next_test();
|
|
}
|
|
|
|
tests.FLUSHDB = function () {
|
|
var name = "FLUSHDB";
|
|
client.mset(["flush keys 1", "flush val 1", "flush keys 2", "flush val 2"], require_string("OK", name));
|
|
client.FLUSHDB([], require_string("OK", name));
|
|
client.dbsize([], last(name, require_number(0, name)));
|
|
};
|
|
|
|
tests.EXISTS = function () {
|
|
var name = "EXISTS";
|
|
client.del(["foo", "foo2"], require_number_any(name));
|
|
client.set(['foo', 'bar'], require_string("OK", name));
|
|
client.EXISTS(['foo'], require_number(1, name));
|
|
client.EXISTS(['foo2'], last(name, require_number(0, name)));
|
|
};
|
|
|
|
tests.DEL = function () {
|
|
var name = "DEL";
|
|
client.DEL(["delkey"], require_number_any(name));
|
|
client.set(["delkey", "delvalue"], require_string("OK", name));
|
|
client.DEL(["delkey"], require_number(1, name));
|
|
client.exists(["delkey"], require_number(0, name));
|
|
client.DEL(["delkey"], require_number(0, name));
|
|
client.mset(["delkey", "delvalue", "delkey2", "delvalue2"], require_string("OK", name));
|
|
client.DEL(["delkey", "delkey2"], last(name, require_number(2, name)));
|
|
};
|
|
|
|
tests.TYPE = function () {
|
|
var name = "TYPE";
|
|
client.set(["string key", "should be a string"], require_string("OK", name));
|
|
client.rpush(["list key", "should be a list"], require_number_pos(name));
|
|
client.sadd(["set key", "should be a set"], require_number_any(name));
|
|
client.zadd(["zset key", "10.0", "should be a zset"], require_number_any(name));
|
|
client.hset(["hash key", "hashtest", "should be a hash"], require_number_any(0, name));
|
|
|
|
client.TYPE(["string key"], require_string("string", name));
|
|
client.TYPE(["list key"], require_string("list", name));
|
|
client.TYPE(["set key"], require_string("set", name));
|
|
client.TYPE(["zset key"], require_string("zset", name));
|
|
client.TYPE(["hash key"], last(name, require_string("hash", name)));
|
|
};
|
|
|
|
tests.KEYS = function () {
|
|
var name = "KEYS";
|
|
client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], require_string("OK", name));
|
|
client.KEYS(["test keys*"], function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(2, results.length, name);
|
|
assert.strictEqual("test keys 1", results[0].toString(), name);
|
|
assert.strictEqual("test keys 2", results[1].toString(), name);
|
|
next(name);
|
|
});
|
|
};
|
|
|
|
tests.RANDOMKEY = function () {
|
|
var name = "RANDOMKEY";
|
|
client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], require_string("OK", name));
|
|
client.RANDOMKEY([], function (err, results) {
|
|
assert.strictEqual(null, err, name + " result sent back unexpected error");
|
|
assert.strictEqual(true, /\w+/.test(results), name);
|
|
next(name);
|
|
});
|
|
};
|
|
|
|
tests.RENAME = function () {
|
|
var name = "RENAME";
|
|
client.set(['foo', 'bar'], require_string("OK", name));
|
|
client.RENAME(["foo", "new foo"], require_string("OK", name));
|
|
client.exists(["foo"], require_number(0, name));
|
|
client.exists(["new foo"], last(name, require_number(1, name)));
|
|
};
|
|
|
|
tests.RENAMENX = function () {
|
|
var name = "RENAMENX";
|
|
client.set(['foo', 'bar'], require_string("OK", name));
|
|
client.set(['foo2', 'bar2'], require_string("OK", name));
|
|
client.RENAMENX(["foo", "foo2"], require_number(0, name));
|
|
client.exists(["foo"], require_number(1, name));
|
|
client.exists(["foo2"], require_number(1, name));
|
|
client.del(["foo2"], require_number(1, name));
|
|
client.RENAMENX(["foo", "foo2"], require_number(1, name));
|
|
client.exists(["foo"], require_number(0, name));
|
|
client.exists(["foo2"], last(name, require_number(1, name)));
|
|
};
|
|
|
|
tests.DBSIZE = function () {
|
|
var name = "DBSIZE";
|
|
client.set(['foo', 'bar'], require_string("OK", name));
|
|
client.DBSIZE([], last(name, require_number_pos("DBSIZE")));
|
|
};
|
|
|
|
tests.EXPIRE = function () {
|
|
var name = "EXPIRE";
|
|
client.set(['expiry key', 'bar'], require_string("OK", name));
|
|
client.EXPIRE(["expiry key", "1"], require_number_pos(name));
|
|
console.log("setTimeout 2000...");
|
|
setTimeout(function () {
|
|
client.exists(["expiry key"], last(name, require_number(0, name)));
|
|
}, 2000);
|
|
};
|
|
|
|
tests.TTL = function () {
|
|
var name = "TTL";
|
|
client.set(["ttl key", "ttl val"], require_string("OK", name));
|
|
client.expire(["ttl key", "100"], require_number_pos(name));
|
|
console.log("setTimeout 500...");
|
|
setTimeout(function () {
|
|
client.TTL(["ttl key"], last(name, require_number_pos(0, name)));
|
|
}, 500);
|
|
};
|
|
|
|
tests.GET = function () {
|
|
var name = "GET";
|
|
client.set(["get key", "get val"], require_string("OK", name));
|
|
client.GET(["get key"], last(name, require_string("get val", name)));
|
|
};
|
|
|
|
tests.SET = function () {
|
|
var name = "SET";
|
|
client.SET(["set key", "set val"], require_string("OK", name));
|
|
client.get(["set key"], last(name, require_string("set val", name)));
|
|
};
|
|
|
|
tests.GETSET = function () {
|
|
var name = "GETSET";
|
|
client.set(["getset key", "getset val"], require_string("OK", name));
|
|
client.GETSET(["getset key", "new getset val"], require_string("getset val", name));
|
|
client.get(["getset key"], last(name, require_string("new getset val", name)));
|
|
};
|
|
|
|
tests.MGET = function () {
|
|
var name = "MGET";
|
|
client.mset(["mget keys 1", "mget val 1", "mget keys 2", "mget val 2", "mget keys 3", "mget val 3"], require_string("OK", name));
|
|
client.MGET(["mget keys 1", "mget keys 2", "mget keys 3"], function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(3, results.length, name);
|
|
assert.strictEqual("mget val 1", results[0].toString(), name);
|
|
assert.strictEqual("mget val 2", results[1].toString(), name);
|
|
assert.strictEqual("mget val 3", results[2].toString(), name);
|
|
});
|
|
client.MGET(["mget keys 1", "some random shit", "mget keys 2", "mget keys 3"], function (err, results) {
|
|
assert.strictEqual(null, err, "result sent back unexpected error");
|
|
assert.strictEqual(4, results.length, name);
|
|
assert.strictEqual("mget val 1", results[0].toString(), name);
|
|
assert.strictEqual(null, results[1], name);
|
|
assert.strictEqual("mget val 2", results[2].toString(), name);
|
|
assert.strictEqual("mget val 3", results[3].toString(), name);
|
|
next(name);
|
|
});
|
|
};
|
|
|
|
tests.SETNX = function () {
|
|
var name = "SETNX";
|
|
client.set(["setnx key", "setnx value"], require_string("OK", name));
|
|
client.SETNX(["setnx key", "new setnx value"], require_number(0, name));
|
|
client.del(["setnx key"], require_number(1, name));
|
|
client.exists(["setnx key"], require_number(0, name));
|
|
client.SETNX(["setnx key", "new setnx value"], require_number(1, name));
|
|
client.exists(["setnx key"], last(name, require_number(1, name)));
|
|
};
|
|
|
|
tests.SETEX = function () {
|
|
var name = "SETEX";
|
|
client.SETEX(["setex key", "100", "setex val"], require_string("OK", name));
|
|
client.exists(["setex key"], require_number(1, name));
|
|
client.ttl(["setex key"], last(name, require_number_pos(name)));
|
|
};
|
|
|
|
// plenty of tests of MSET already
|
|
|
|
tests.MSETNX = function () {
|
|
var name = "MSETNX";
|
|
client.mset(["mset1", "val1", "mset2", "val2", "mset3", "val3"], require_string("OK", name));
|
|
client.MSETNX(["mset3", "val3", "mset4", "val4"], require_number(0, name));
|
|
client.del(["mset3"], require_number(1, name));
|
|
client.MSETNX(["mset3", "val3", "mset4", "val4"], require_number(1, name));
|
|
client.exists(["mset3"], require_number(1, name));
|
|
client.exists(["mset4"], last(name, require_number(1, name)));
|
|
};
|
|
|
|
tests.MULTI = function () {
|
|
name = "MULTI";
|
|
client.multi([
|
|
["mset", ["multifoo", "10", "multibar", "20"], require_string("OK", name)],
|
|
["set", ["foo2"], require_error(name)],
|
|
["incr", ["multifoo"], require_number(11, name)],
|
|
["incr", ["multibar"], require_number(21, name)]
|
|
]);
|
|
|
|
client.multi([
|
|
["incr", ["multibar"], require_number(22, name)],
|
|
["incr", ["multifoo"], last(name, require_number(12, name))]
|
|
]);
|
|
};
|
|
|
|
tests.HGETALL = function () {
|
|
name = "HGETALL";
|
|
client.hmset(["hosts", "mjr", "1", "another", "23", "home", "1234"], require_string("OK", name));
|
|
client.HGETALL(["hosts"], function (err, results) {
|
|
assert.strictEqual(null, err, name + " result sent back unexpected error");
|
|
assert.strictEqual(6, results.length, name);
|
|
assert.strictEqual("mjr", results[0].toString(), name);
|
|
assert.strictEqual("1", results[1].toString(), name);
|
|
assert.strictEqual("another", results[2].toString(), name);
|
|
assert.strictEqual("23", results[3].toString(), name);
|
|
assert.strictEqual("home", results[4].toString(), name);
|
|
assert.strictEqual("1234", results[5].toString(), name);
|
|
next(name);
|
|
});
|
|
};
|
|
|
|
var all_tests = Object.keys(tests),
|
|
all_start = new Date(), cur_start, test_count = 0;
|
|
|
|
function run_next_test() {
|
|
var test_name = all_tests.shift();
|
|
if (typeof tests[test_name] === "function") {
|
|
console.log(test_name + " started");
|
|
cur_start = new Date();
|
|
test_count += 1;
|
|
tests[test_name]();
|
|
} else {
|
|
console.log(test_count + " tests completed in " + (Date.now() - all_start));
|
|
process.exit();
|
|
}
|
|
}
|
|
|
|
client.on("connect", function () {
|
|
console.log("Tester got connection, initializing database for tests.");
|
|
run_next_test();
|
|
});
|
|
|
|
client.on("error", function (err) {
|
|
console.log("Redis clent connection failed.");
|
|
});
|
|
|
|
client.on("reconnecting", function (msg) {
|
|
console.log("reconnecting: " + msg);
|
|
});
|
|
|
|
process.on('uncaughtException', function (err) {
|
|
console.log("Uncaught exception: " + err.stack);
|
|
});
|
|
|