finished porting blpop, expire, mset, slowlog, sunionstore, ttl

test/commands/blpop.spec.js

@@ -0,0 +1,64 @@
+var assert = require("assert");
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+
+describe("The 'blpop' method", function () {
+
+    function allTests(parser, ip) {
+        var args = config.configureClient(parser, ip);
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+            var bclient;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('pops value immediately if list contains values', function (done) {
+                bclient = redis.createClient.apply(redis.createClient, args);
+                client.rpush("blocking list", "initial value", helper.isNumber(1));
+                bclient.blpop("blocking list", 0, function (err, value) {
+                    assert.strictEqual(value[0], "blocking list");
+                    assert.strictEqual(value[1], "initial value");
+                    return done(err);
+                });
+            });
+
+            it('waits for value if list is not yet populated', function (done) {
+                bclient = redis.createClient.apply(redis.createClient, args);
+                bclient.blpop("blocking list 2", 5, function (err, value) {
+                    assert.strictEqual(value[0], "blocking list 2");
+                    assert.strictEqual(value[1], "initial value");
+                    return done(err);
+                });
+                client.rpush("blocking list 2", "initial value", helper.isNumber(1));
+            });
+
+            it('times out after specified time', function (done) {
+                bclient = redis.createClient.apply(redis.createClient, args);
+                bclient.BLPOP("blocking list", 1, function (err, res) {
+                    assert.strictEqual(res, null);
+                    return done(err);
+                });
+            });
+
+            afterEach(function () {
+                client.end();
+                bclient.end();
+            });
+        });
+    }
+
+    ['javascript', 'hiredis'].forEach(function (parser) {
+        allTests(parser, "/tmp/redis.sock");
+        ['IPv4', 'IPv6'].forEach(function (ip) {
+            allTests(parser, ip);
+        })
+    });
+});

test/commands/expire.spec.js

@@ -0,0 +1,42 @@
+var assert = require("assert");
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+
+describe("The 'expire' method", function () {
+
+    function allTests(parser, ip) {
+        var args = config.configureClient(parser, ip);
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('expires key after timeout', function (done) {
+                client.set(['expiry key', 'bar'], helper.isString("OK"));
+                client.EXPIRE(["expiry key", "1"], helper.isNumber(1));
+                setTimeout(function () {
+                    client.exists(["expiry key"], helper.isNumber(0, done));
+                }, 1500);
+            });
+
+            afterEach(function () {
+                client.end();
+            });
+        });
+    }
+
+    ['javascript', 'hiredis'].forEach(function (parser) {
+        allTests(parser, "/tmp/redis.sock");
+        ['IPv4', 'IPv6'].forEach(function (ip) {
+            allTests(parser, ip);
+        })
+    });
+});

test/commands/mset.spec.js

@@ -66,22 +66,9 @@ describe("The 'mset' method", function () {
                 describe("and a callback is specified", function () {
                     describe("with valid parameters", function () {
                         it("sets the value correctly", function (done) {
-                            client.mset(key, value, key2, value2, function (err, res) {
+                            client.mset(key, value, key2, value2);
-                                helper.isNotError()(err, res);
+                            client.get(key, helper.isString(value));
-                                async.parallel([function (next) {
+                            client.get(key2, helper.isString(value2, done));
-                                    client.get(key, function (err, res) {
-                                        helper.isString(value)(err, res);
-                                        next();
-                                    });
-                                }, function (next) {
-                                    client.get(key2, function (err, res) {
-                                        helper.isString(value2)(err, res);
-                                        next();
-                                    });
-                                }], function (err) {
-                                    done(err);
-                                });
-                            });
                         });
                     });
 
@@ -108,22 +95,8 @@ describe("The 'mset' method", function () {
                     describe("with valid parameters", function () {
                         it("sets the value correctly", function (done) {
                             client.mset(key, value, key2, value2);
-
+                            client.get(key, helper.isString(value));
-                            setTimeout(function () {
+                            client.get(key2, helper.isString(value2, done));
-                                async.parallel([function (next) {
-                                    client.get(key, function (err, res) {
-                                        helper.isString(value)(err, res);
-                                        next();
-                                    });
-                                }, function (next) {
-                                    client.get(key2, function (err, res) {
-                                        helper.isString(value2)(err, res);
-                                        next();
-                                    });
-                                }], function (err) {
-                                    done(err);
-                                });
-                            }, 100);
                         });
                     });
 

test/commands/slowlog.spec.js

@@ -0,0 +1,48 @@
+var assert = require("assert");
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+
+describe("The 'slowlog' method", function () {
+
+    function allTests(parser, ip) {
+        var args = config.configureClient(parser, ip);
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('logs operations in slowlog', function (done) {
+                client.config("set", "slowlog-log-slower-than", 0, helper.isString("OK"));
+                client.slowlog("reset", helper.isString("OK"));
+                client.set("foo", "bar", helper.isString("OK"));
+                client.get("foo", helper.isString("bar"));
+                client.slowlog("get", function (err, res) {
+                    assert.equal(res.length, 3);
+                    assert.equal(res[0][3].length, 2);
+                    assert.deepEqual(res[1][3], ["set", "foo", "bar"]);
+                    assert.deepEqual(res[2][3], ["slowlog", "reset"]);
+                    return done(err);
+                });
+            });
+
+            afterEach(function () {
+                client.end();
+            });
+        });
+    }
+
+    ['javascript', 'hiredis'].forEach(function (parser) {
+        allTests(parser, "/tmp/redis.sock");
+        ['IPv4', 'IPv6'].forEach(function (ip) {
+            allTests(parser, ip);
+        })
+    });
+});

test/commands/sunionstore.spec.js

@@ -0,0 +1,56 @@
+var assert = require("assert");
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+
+describe("The 'sunionstore' method", function () {
+
+    function allTests(parser, ip) {
+        var args = config.configureClient(parser, ip);
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('stores the result of a union', function (done) {
+                client.sadd('sa', 'a', helper.isNumber(1));
+                client.sadd('sa', 'b', helper.isNumber(1));
+                client.sadd('sa', 'c', helper.isNumber(1));
+
+                client.sadd('sb', 'b', helper.isNumber(1));
+                client.sadd('sb', 'c', helper.isNumber(1));
+                client.sadd('sb', 'd', helper.isNumber(1));
+
+                client.sadd('sc', 'c', helper.isNumber(1));
+                client.sadd('sc', 'd', helper.isNumber(1));
+                client.sadd('sc', 'e', helper.isNumber(1));
+
+                client.sunionstore('foo', 'sa', 'sb', 'sc', helper.isNumber(5));
+
+                client.smembers('foo', function (err, members) {
+                    assert.equal(members.length, 5);
+                    assert.deepEqual(members.sort(), ['a', 'b', 'c', 'd', 'e']);
+                    return done(err);
+                });
+            });
+
+            afterEach(function () {
+                client.end();
+            });
+        });
+    }
+
+    ['javascript', 'hiredis'].forEach(function (parser) {
+        allTests(parser, "/tmp/redis.sock");
+        ['IPv4', 'IPv6'].forEach(function (ip) {
+            allTests(parser, ip);
+        })
+    });
+});

test/commands/ttl.spec.js

@@ -0,0 +1,45 @@
+var assert = require("assert");
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+
+describe("The 'ttl' method", function () {
+
+    function allTests(parser, ip) {
+        var args = config.configureClient(parser, ip);
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('returns the current ttl on a key', function (done) {
+                client.set(["ttl key", "ttl val"], helper.isString("OK"));
+                client.expire(["ttl key", "100"], helper.isNumber(1));
+                setTimeout(function () {
+                    client.TTL(["ttl key"], function (err, ttl) {
+                        assert.ok(ttl > 50 && ttl <= 100);
+                        return done(err);
+                    });
+                }, 500);
+            });
+
+            afterEach(function () {
+                client.end();
+            });
+        });
+    }
+
+    ['javascript', 'hiredis'].forEach(function (parser) {
+        allTests(parser, "/tmp/redis.sock");
+        ['IPv4', 'IPv6'].forEach(function (ip) {
+            allTests(parser, ip);
+        })
+    });
+});

test/test.js

@@ -1,120 +0,0 @@
-return;
-
-tests.SUNIONSTORE = function () {
-    var name = "SUNIONSTORE";
-
-    client.del('sa');
-    client.del('sb');
-    client.del('sc');
-    client.del('foo');
-
-    client.sadd('sa', 'a', require_number(1, name));
-    client.sadd('sa', 'b', require_number(1, name));
-    client.sadd('sa', 'c', require_number(1, name));
-
-    client.sadd('sb', 'b', require_number(1, name));
-    client.sadd('sb', 'c', require_number(1, name));
-    client.sadd('sb', 'd', require_number(1, name));
-
-    client.sadd('sc', 'c', require_number(1, name));
-    client.sadd('sc', 'd', require_number(1, name));
-    client.sadd('sc', 'e', require_number(1, name));
-
-    client.sunionstore('foo', 'sa', 'sb', 'sc', function (err, cardinality) {
-        if (err) {
-            assert.fail(err, name);
-        }
-        assert.equal(cardinality, 5, name);
-    });
-
-    client.smembers('foo', function (err, members) {
-        if (err) {
-            assert.fail(err, name);
-        }
-        assert.equal(members.length, 5, name);
-        assert.deepEqual(buffers_to_strings(members).sort(), ['a', 'b', 'c', 'd', 'e'], name);
-        next(name);
-    });
-};
-
-tests.BLPOP = function () {
-    var name = "BLPOP";
-
-    client.rpush("blocking list", "initial value", function (err, res) {
-        client2.BLPOP("blocking list", 0, function (err, res) {
-            assert.strictEqual("blocking list", res[0].toString());
-            assert.strictEqual("initial value", res[1].toString());
-
-            client.rpush("blocking list", "wait for this value");
-        });
-        client2.BLPOP("blocking list", 0, function (err, res) {
-            assert.strictEqual("blocking list", res[0].toString());
-            assert.strictEqual("wait for this value", res[1].toString());
-            next(name);
-        });
-    });
-};
-
-tests.BLPOP_TIMEOUT = function () {
-    var name = "BLPOP_TIMEOUT";
-
-    // try to BLPOP the list again, which should be empty.  This should timeout and return null.
-    client2.BLPOP("blocking list", 1, function (err, res) {
-        if (err) {
-            throw err;
-        }
-
-        assert.strictEqual(res, null);
-        next(name);
-    });
-};
-
-tests.EXPIRE = function () {
-    var name = "EXPIRE";
-    client.set(['expiry key', 'bar'], require_string("OK", name));
-    client.EXPIRE(["expiry key", "1"], require_number_pos(name));
-    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));
-    setTimeout(function () {
-        client.TTL(["ttl key"], last(name, require_number_pos(0, name)));
-    }, 500);
-};
-
-tests.OPTIONAL_CALLBACK = function () {
-    var name = "OPTIONAL_CALLBACK";
-    client.del("op_cb1");
-    client.set("op_cb1", "x");
-    client.get("op_cb1", last(name, require_string("x", name)));
-};
-
-tests.OPTIONAL_CALLBACK_UNDEFINED = function () {
-    var name = "OPTIONAL_CALLBACK_UNDEFINED";
-    client.del("op_cb2");
-    client.set("op_cb2", "y", undefined);
-    client.get("op_cb2", last(name, require_string("y", name)));
-
-    client.set("op_cb_undefined", undefined, undefined);
-};
-
-tests.SLOWLOG = function () {
-    var name = "SLOWLOG";
-    client.config("set", "slowlog-log-slower-than", 0, require_string("OK", name));
-    client.slowlog("reset", require_string("OK", name));
-    client.set("foo", "bar", require_string("OK", name));
-    client.get("foo", require_string("bar", name));
-    client.slowlog("get", function (err, res) {
-        assert.equal(res.length, 3, name);
-        assert.equal(res[0][3].length, 2, name);
-        assert.deepEqual(res[1][3], ["set", "foo", "bar"], name);
-        assert.deepEqual(res[2][3], ["slowlog", "reset"], name);
-        client.config("set", "slowlog-log-slower-than", 10000, require_string("OK", name));
-        next(name);
-    });
-};