redis 0.6.7 → 0.7.3

package/test.js

@@ -3,9 +3,9 @@ var redis = require("./index"),
     client = redis.createClient(),
     client2 = redis.createClient(),
     client3 = redis.createClient(),
-    client4 = redis.createClient(9006, "filefish.redistogo.com"),
     assert = require("assert"),
-    util = require("./lib/util").util,
+    crypto = require("crypto"),
+    util = require("./lib/util"),
     test_db_num = 15, // this DB will be flushed and used for testing
     tests = {},
     connected = false,
@@ -23,7 +23,7 @@ function buffers_to_strings(arr) {
 
 function require_number(expected, label) {
     return function (err, results) {
-        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual(null, err, label + " expected " + expected + ", got error: " + err);
         assert.strictEqual(expected, results, label + " " + expected + " !== " + results);
         assert.strictEqual(typeof results, "number", label);
         return true;
@@ -32,7 +32,7 @@ function require_number(expected, label) {
 
 function require_number_any(label) {
     return function (err, results) {
-        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual(null, err, label + " expected any number, got error: " + err);
         assert.strictEqual(typeof results, "number", label + " " + results + " is not a number");
         return true;
     };
@@ -40,7 +40,7 @@ function require_number_any(label) {
 
 function require_number_pos(label) {
     return function (err, results) {
-        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual(null, err, label + " expected positive number, got error: " + err);
         assert.strictEqual(true, (results > 0), label + " " + results + " is not a positive number");
         return true;
     };
@@ -48,7 +48,7 @@ function require_number_pos(label) {
 
 function require_string(str, label) {
     return function (err, results) {
-        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual(null, err, label + " expected string '" + str + "', got error: " + err);
         assert.equal(str, results, label + " " + str + " does not match " + results);
         return true;
     };
@@ -56,7 +56,7 @@ function require_string(str, label) {
 
 function require_null(label) {
     return function (err, results) {
-        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual(null, err, label + " expected null, got error: " + err);
         assert.strictEqual(null, results, label + ": " + results + " is not null");
         return true;
     };
@@ -69,7 +69,7 @@ function require_error(label) {
     };
 }
 
-function is_empty_array(obj) { 
+function is_empty_array(obj) {
     return Array.isArray(obj) && obj.length === 0;
 }
 
@@ -157,7 +157,7 @@ tests.MULTI_3 = function () {
         // make sure empty mb reply works
         assert.strictEqual(true, is_empty_array(reply), name);
     });
- 
+
     // test nested multi-bulk replies with empty mb elements.
     client.multi([
         ["smembers", "some set"],
@@ -230,7 +230,7 @@ tests.MULTI_6 = function () {
 tests.EVAL_1 = function () {
     var name = "EVAL_1";
 
-    if (client.server_info.versions[0] >= 2 && client.server_info.versions[1] >= 9) {
+    if (client.server_info.versions[0] >= 2 && client.server_info.versions[1] >= 5) {
         // test {EVAL - Lua integer -> Redis protocol type conversion}
         client.eval("return 100.5", 0, require_number(100, name));
         // test {EVAL - Lua string -> Redis protocol type conversion}
@@ -262,62 +262,89 @@ tests.EVAL_1 = function () {
             assert.strictEqual("c", res[2], name);
             assert.strictEqual("d", res[3], name);
         });
-        // test {EVAL - is Lua able to call Redis API?}
-        client.set("mykey", "myval");
-        client.eval("return redis.call('get','mykey')", 0, require_string("myval", name));
-        // test {EVALSHA - Can we call a SHA1 if already defined?}
-        client.evalsha("9bd632c7d33e571e9f24556ebed26c3479a87129", 0, require_string("myval", name));
-        // test {EVALSHA - Do we get an error on non defined SHA1?}
-        client.evalsha("ffffffffffffffffffffffffffffffffffffffff", 0, require_error(name));
+
+        // prepare sha sum for evalsha cache test
+        var source = "return redis.call('get', 'sha test')",
+            sha = crypto.createHash('sha1').update(source).digest('hex');
+
+        client.set("sha test", "eval get sha test", function (err, res) {
+            if (err) throw err;
+            // test {EVAL - is Lua able to call Redis API?}
+            client.eval(source, 0, function (err, res) {
+                require_string("eval get sha test", name)(err, res);
+                // test {EVALSHA - Can we call a SHA1 if already defined?}
+                client.evalsha(sha, 0, require_string("eval get sha test", name));
+                // test {EVALSHA - Do we get an error on non defined SHA1?}
+                client.evalsha("ffffffffffffffffffffffffffffffffffffffff", 0, require_error(name));
+            });
+        });
+
         // test {EVAL - Redis integer -> Lua type conversion}
-        client.set("x", 0);
-        client.eval("local foo = redis.call('incr','x')\n" + "return {type(foo),foo}", 0, function (err, res) {
-            assert.strictEqual(2, res.length, name);
-            assert.strictEqual("number", res[0], name);
-            assert.strictEqual(1, res[1], name);
+        client.set("incr key", 0, function (err, reply) {
+            if (err) throw err;
+            client.eval("local foo = redis.call('incr','incr key')\n" + "return {type(foo),foo}", 0, function (err, res) {
+                if (err) throw err;
+                assert.strictEqual(2, res.length, name);
+                assert.strictEqual("number", res[0], name);
+                assert.strictEqual(1, res[1], name);
+            });
         });
-        // test {EVAL - Redis bulk -> Lua type conversion}
-        client.eval("local foo = redis.call('get','mykey'); return {type(foo),foo}", 0, function (err, res) {
-            assert.strictEqual(2, res.length, name);
-            assert.strictEqual("string", res[0], name);
-            assert.strictEqual("myval", res[1], name);
+
+        client.set("bulk reply key", "bulk reply value", function (err, res) {
+            // test {EVAL - Redis bulk -> Lua type conversion}
+            client.eval("local foo = redis.call('get','bulk reply key'); return {type(foo),foo}", 0, function (err, res) {
+                if (err) throw err;
+                assert.strictEqual(2, res.length, name);
+                assert.strictEqual("string", res[0], name);
+                assert.strictEqual("bulk reply value", res[1], name);
+            });
         });
+
         // test {EVAL - Redis multi bulk -> Lua type conversion}
-        client.del("mylist");
-        client.rpush("mylist", "a");
-        client.rpush("mylist", "b");
-        client.rpush("mylist", "c");
-        client.eval("local foo = redis.call('lrange','mylist',0,-1)\n" + "return {type(foo),foo[1],foo[2],foo[3],# foo}", 0, function (err, res) {
-            assert.strictEqual(5, res.length, name);
-            assert.strictEqual("table", res[0], name);
-            assert.strictEqual("a", res[1], name);
-            assert.strictEqual("b", res[2], name);
-            assert.strictEqual("c", res[3], name);
-            assert.strictEqual(3, res[4], name);
-        });
+        client.multi()
+            .del("mylist")
+            .rpush("mylist", "a")
+            .rpush("mylist", "b")
+            .rpush("mylist", "c")
+            .exec(function (err, replies) {
+                if (err) throw err;
+                client.eval("local foo = redis.call('lrange','mylist',0,-1); return {type(foo),foo[1],foo[2],foo[3],# foo}", 0, function (err, res) {
+                    assert.strictEqual(5, res.length, name);
+                    assert.strictEqual("table", res[0], name);
+                    assert.strictEqual("a", res[1], name);
+                    assert.strictEqual("b", res[2], name);
+                    assert.strictEqual("c", res[3], name);
+                    assert.strictEqual(3, res[4], name);
+                });
+            });
         // test {EVAL - Redis status reply -> Lua type conversion}
         client.eval("local foo = redis.call('set','mykey','myval'); return {type(foo),foo['ok']}", 0, function (err, res) {
+            if (err) throw err;
             assert.strictEqual(2, res.length, name);
             assert.strictEqual("table", res[0], name);
             assert.strictEqual("OK", res[1], name);
         });
         // test {EVAL - Redis error reply -> Lua type conversion}
-        client.set("mykey", "myval");
-        client.eval("local foo = redis.call('incr','mykey'); return {type(foo),foo['err']}", 0, function (err, res) {
-            assert.strictEqual(2, res.length, name);
-            assert.strictEqual("table", res[0], name);
-            assert.strictEqual("ERR value is not an integer or out of range", res[1], name);
+        client.set("error reply key", "error reply value", function (err, res) {
+            if (err) throw err;
+            client.eval("local foo = redis.pcall('incr','error reply key'); return {type(foo),foo['err']}", 0, function (err, res) {
+                if (err) throw err;
+                assert.strictEqual(2, res.length, name);
+                assert.strictEqual("table", res[0], name);
+                assert.strictEqual("ERR value is not an integer or out of range", res[1], name);
+            });
         });
         // test {EVAL - Redis nil bulk reply -> Lua type conversion}
-        client.del("mykey");
-        client.eval("local foo = redis.call('get','mykey'); return {type(foo),foo == false}", 0, function (err, res) {
-            assert.strictEqual(2, res.length, name);
-            assert.strictEqual("boolean", res[0], name);
-            assert.strictEqual(1, res[1], name);
+        client.del("nil reply key", function (err, res) {
+            if (err) throw err;
+            client.eval("local foo = redis.call('get','nil reply key'); return {type(foo),foo == false}", 0, function (err, res) {
+                if (err) throw err;
+                assert.strictEqual(2, res.length, name);
+                assert.strictEqual("boolean", res[0], name);
+                assert.strictEqual(1, res[1], name);
+                next(name);
+            });
         });
-        // test {EVAL - Script can't run more than configured time limit} {
-        client.config("set", "lua-time-limit", 1);
-        client.eval("local i = 0; while true do i=i+1 end", 0, last("name", require_error(name)));
     } else {
         console.log("Skipping " + name + " because server version isn't new enough.");
         next(name);
@@ -339,6 +366,114 @@ tests.WATCH_MULTI = function () {
     }
 };
 
+tests.detect_buffers = function () {
+    var name = "detect_buffers", detect_client = redis.createClient(null, null, {detect_buffers: true});
+
+    detect_client.on("ready", function () {
+        // single Buffer or String
+        detect_client.set("string key 1", "string value");
+        detect_client.get("string key 1", require_string("string value", name));
+        detect_client.get(new Buffer("string key 1"), function (err, reply) {
+            assert.strictEqual(null, err, name);
+            assert.strictEqual(true, Buffer.isBuffer(reply), name);
+            assert.strictEqual("<Buffer 73 74 72 69 6e 67 20 76 61 6c 75 65>", reply.inspect(), name);
+        });
+
+        detect_client.hmset("hash key 2", "key 1", "val 1", "key 2", "val 2");
+        // array of Buffers or Strings
+        detect_client.hmget("hash key 2", "key 1", "key 2", function (err, reply) {
+            assert.strictEqual(null, err, name);
+            assert.strictEqual(true, Array.isArray(reply), name);
+            assert.strictEqual(2, reply.length, name);
+            assert.strictEqual("val 1", reply[0], name);
+            assert.strictEqual("val 2", reply[1], name);
+        });
+        detect_client.hmget(new Buffer("hash key 2"), "key 1", "key 2", function (err, reply) {
+            assert.strictEqual(null, err, name);
+            assert.strictEqual(true, Array.isArray(reply));
+            assert.strictEqual(2, reply.length, name);
+            assert.strictEqual(true, Buffer.isBuffer(reply[0]));
+            assert.strictEqual(true, Buffer.isBuffer(reply[1]));
+            assert.strictEqual("<Buffer 76 61 6c 20 31>", reply[0].inspect(), name);
+            assert.strictEqual("<Buffer 76 61 6c 20 32>", reply[1].inspect(), name);
+        });
+
+        // Object of Buffers or Strings
+        detect_client.hgetall("hash key 2", function (err, reply) {
+            assert.strictEqual(null, err, name);
+            assert.strictEqual("object", typeof reply, name);
+            assert.strictEqual(2, Object.keys(reply).length, name);
+            assert.strictEqual("val 1", reply["key 1"], name);
+            assert.strictEqual("val 2", reply["key 2"], name);
+        });
+        detect_client.hgetall(new Buffer("hash key 2"), function (err, reply) {
+            assert.strictEqual(null, err, name);
+            assert.strictEqual("object", typeof reply, name);
+            assert.strictEqual(2, Object.keys(reply).length, name);
+            assert.strictEqual(true, Buffer.isBuffer(reply["key 1"]));
+            assert.strictEqual(true, Buffer.isBuffer(reply["key 2"]));
+            assert.strictEqual("<Buffer 76 61 6c 20 31>", reply["key 1"].inspect(), name);
+            assert.strictEqual("<Buffer 76 61 6c 20 32>", reply["key 2"].inspect(), name);
+        });
+
+        detect_client.quit(function (err, res) {
+            next(name);
+        });
+    });
+};
+
+tests.socket_nodelay = function () {
+    var name = "socket_nodelay", c1, c2, c3, ready_count = 0, quit_count = 0;
+
+    c1 = redis.createClient(null, null, {socket_nodelay: true});
+    c2 = redis.createClient(null, null, {socket_nodelay: false});
+    c3 = redis.createClient(null, null);
+
+    function quit_check() {
+        quit_count++;
+
+        if (quit_count === 3) {
+            next(name);
+        }
+    }
+
+    function run() {
+        assert.strictEqual(true, c1.options.socket_nodelay, name);
+        assert.strictEqual(false, c2.options.socket_nodelay, name);
+        assert.strictEqual(true, c3.options.socket_nodelay, name);
+
+        c1.set(["set key 1", "set val"], require_string("OK", name));
+        c1.set(["set key 2", "set val"], require_string("OK", name));
+        c1.get(["set key 1"], require_string("set val", name));
+        c1.get(["set key 2"], require_string("set val", name));
+
+        c2.set(["set key 3", "set val"], require_string("OK", name));
+        c2.set(["set key 4", "set val"], require_string("OK", name));
+        c2.get(["set key 3"], require_string("set val", name));
+        c2.get(["set key 4"], require_string("set val", name));
+
+        c3.set(["set key 5", "set val"], require_string("OK", name));
+        c3.set(["set key 6", "set val"], require_string("OK", name));
+        c3.get(["set key 5"], require_string("set val", name));
+        c3.get(["set key 6"], require_string("set val", name));
+
+        c1.quit(quit_check);
+        c2.quit(quit_check);
+        c3.quit(quit_check);
+    }
+
+    function ready_check() {
+        ready_count++;
+        if (ready_count === 3) {
+            run();
+        }
+    }
+
+    c1.on("ready", ready_check);
+    c2.on("ready", ready_check);
+    c3.on("ready", ready_check);
+};
+
 tests.reconnect = function () {
     var name = "reconnect";
 
@@ -348,7 +483,7 @@ tests.reconnect = function () {
         // For orderly shutdown in normal programs, do client.quit()
         client.stream.destroy();
     });
-    
+
     client.on("reconnecting", function on_recon(params) {
         client.on("connect", function on_connect() {
             client.select(test_db_num, require_string("OK", name));
@@ -363,6 +498,17 @@ tests.reconnect = function () {
     });
 };
 
+tests.idle = function () {
+  var name = "idle";
+
+  client.on("idle", function on_idle() {
+    client.removeListener("idle", on_idle);
+    next(name);
+  });
+
+  client.set("idle", "test");
+};
+
 tests.HSET = function () {
     var key = "test hash",
         field1 = new Buffer("0123456789"),
@@ -383,6 +529,23 @@ tests.HSET = function () {
     client.HSET(key, field2, value2, last(name, require_number(0, name)));
 };
 
+tests.HLEN = function () {
+    var key = "test hash",
+        field1 = new Buffer("0123456789"),
+        value1 = new Buffer("abcdefghij"),
+        field2 = new Buffer(0),
+        value2 = new Buffer(0),
+        name = "HSET",
+        timeout = 1000;
+
+    client.HSET(key, field1, value1, function (err, results) {
+        client.HLEN(key, function (err, len) {
+            assert.ok(2 === +len);
+            next(name);
+        });
+    });
+}
+
 tests.HMSET_BUFFER_AND_ARRAY = function () {
     // Saving a buffer and an array to the same key should not error
     var key = "test hash",
@@ -395,7 +558,7 @@ tests.HMSET_BUFFER_AND_ARRAY = function () {
     client.HMSET(key, field1, value1, field2, value2, last(name, require_string("OK", name)));
 };
 
-// TODO - add test for HMSET.  It is special.  Test for all forms as well as optional callbacks
+// TODO - add test for HMSET with optional callbacks
 
 tests.HMGET = function () {
     var key1 = "test hash 1", key2 = "test hash 2", name = "HMGET";
@@ -469,7 +632,25 @@ tests.SUBSCRIBE = function () {
     });
 
     client1.set("did a thing", 1, require_string("OK", name));
-    client1.subscribe("chan1", "chan2");
+    client1.subscribe("chan1", "chan2", function (err, results) {
+        assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+        assert.strictEqual("chan1", results.toString(), name);
+    });
+};
+
+tests.SUB_UNSUB_SUB = function () {
+    var name = "SUB_UNSUB_SUB";
+    client3.subscribe('chan3');
+    client3.unsubscribe('chan3');
+    client3.subscribe('chan3', function (err, results) {
+        assert.strictEqual(null, err, "unexpected error: " + err);
+        client2.publish('chan3', 'foo');
+    });
+    client3.on('message', function (channel, message) {
+        assert.strictEqual(channel, 'chan3');
+        assert.strictEqual(message, 'foo');
+        next(name);
+    });
 };
 
 tests.SUBSCRIBE_QUIT = function () {
@@ -483,6 +664,66 @@ tests.SUBSCRIBE_QUIT = function () {
     client3.subscribe("chan3");
 };
 
+tests.SUBSCRIBE_CLOSE_RESUBSCRIBE = function () {
+    var name = "SUBSCRIBE_CLOSE_RESUBSCRIBE";
+    var c1 = redis.createClient();
+    var c2 = redis.createClient();
+    var count = 0;
+
+    /* Create two clients. c1 subscribes to two channels, c2 will publish to them.
+       c2 publishes the first message.
+       c1 gets the message and drops its connection. It must resubscribe itself.
+       When it resubscribes, c2 publishes the second message, on the same channel
+       c1 gets the message and drops its connection. It must resubscribe itself, again.
+       When it resubscribes, c2 publishes the third message, on the second channel
+       c1 gets the message and drops its connection. When it reconnects, the test ends.
+    */
+
+    c1.on("message", function(channel, message) {
+        if (channel === "chan1") {
+            assert.strictEqual(message, "hi on channel 1");
+            c1.stream.end();
+
+        } else if (channel === "chan2") {
+            assert.strictEqual(message, "hi on channel 2");
+            c1.stream.end();
+
+        } else {
+            c1.quit();
+            c2.quit();
+            assert.fail("test failed");
+        }
+    })
+
+    c1.subscribe("chan1", "chan2");
+
+    c2.once("ready", function() {
+        console.log("c2 is ready");
+        c1.on("ready", function(err, results) {
+            console.log("c1 is ready", count);
+
+            count++;
+            if (count == 1) {
+                c2.publish("chan1", "hi on channel 1");
+                return;
+
+            } else if (count == 2) {
+                c2.publish("chan2", "hi on channel 2");
+
+            } else {
+                c1.quit(function() {
+                    c2.quit(function() {
+                        next(name);
+                    });
+                });
+            }
+        });
+
+        c2.publish("chan1", "hi on channel 1");
+
+    });
+};
+
 tests.EXISTS = function () {
     var name = "EXISTS";
     client.del("foo", "foo2", require_number_any(name));
@@ -509,7 +750,7 @@ tests.TYPE = function () {
     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));
@@ -666,15 +907,15 @@ tests.HGETALL = function () {
 tests.HGETALL_NULL = function () {
     var name = "HGETALL_NULL";
 
-    client.hgetall('missing', function (err, obj) {
+    client.hgetall("missing", function (err, obj) {
         assert.strictEqual(null, err);
-        assert.deepEqual([], obj);
+        assert.strictEqual(null, obj);
         next(name);
     });
 };
 
 tests.UTF8 = function () {
-    var name = "UTF8", 
+    var name = "UTF8",
         utf8_sample = "ಠ_ಠ";
 
     client.set(["utf8test", utf8_sample], require_string("OK", name));
@@ -689,15 +930,15 @@ tests.UTF8 = function () {
 
 tests.SADD = function () {
     var name = "SADD";
-    
+
     client.del('set0');
-    client.sadd('set0', 'member0', require_number(1, name));
+    client.SADD('set0', 'member0', require_number(1, name));
     client.sadd('set0', 'member0', last(name, require_number(0, name)));
 };
 
 tests.SADD2 = function () {
     var name = "SADD2";
-    
+
     client.del("set0");
     client.sadd("set0", ["member0", "member1", "member2"], require_number(3, name));
     client.smembers("set0", function (err, res) {
@@ -705,13 +946,20 @@ tests.SADD2 = function () {
         assert.strictEqual(res[0], "member0");
         assert.strictEqual(res[1], "member1");
         assert.strictEqual(res[2], "member2");
+    });
+    client.SADD("set1", ["member0", "member1", "member2"], require_number(3, name));
+    client.smembers("set1", function (err, res) {
+        assert.strictEqual(res.length, 3);
+        assert.strictEqual(res[0], "member0");
+        assert.strictEqual(res[1], "member1");
+        assert.strictEqual(res[2], "member2");
         next(name);
     });
 };
 
 tests.SISMEMBER = function () {
     var name = "SISMEMBER";
-    
+
     client.del('set0');
     client.sadd('set0', 'member0', require_number(1, name));
     client.sismember('set0', 'member0', require_number(1, name));
@@ -720,7 +968,7 @@ tests.SISMEMBER = function () {
 
 tests.SCARD = function () {
     var name = "SCARD";
-    
+
     client.del('set0');
     client.sadd('set0', 'member0', require_number(1, name));
     client.scard('set0', require_number(1, name));
@@ -740,7 +988,7 @@ tests.SREM = function () {
 
 tests.SPOP = function () {
     var name = "SPOP";
-    
+
     client.del('zzz');
     client.sadd('zzz', 'member0', require_number(1, name));
     client.scard('zzz', require_number(1, name));
@@ -757,7 +1005,7 @@ tests.SPOP = function () {
 
 tests.SDIFF = function () {
     var name = "SDIFF";
-    
+
     client.del('foo');
     client.sadd('foo', 'x', require_number(1, name));
     client.sadd('foo', 'a', require_number(1, name));
@@ -783,7 +1031,7 @@ tests.SDIFF = function () {
 
 tests.SDIFFSTORE = function () {
     var name = "SDIFFSTORE";
-    
+
     client.del('foo');
     client.del('bar');
     client.del('baz');
@@ -799,7 +1047,7 @@ tests.SDIFFSTORE = function () {
     client.sadd('baz', 'a', require_number(1, name));
     client.sadd('baz', 'd', require_number(1, name));
 
-    // NB: SDIFFSTORE returns the number of elements in the dstkey 
+    // NB: SDIFFSTORE returns the number of elements in the dstkey
 
     client.sdiffstore('quux', 'foo', 'bar', 'baz', require_number(2, name));
 
@@ -816,7 +1064,7 @@ tests.SDIFFSTORE = function () {
 
 tests.SMEMBERS = function () {
     var name = "SMEMBERS";
-    
+
     client.del('foo');
     client.sadd('foo', 'x', require_number(1, name));
 
@@ -860,7 +1108,7 @@ tests.SINTER = function () {
     client.del('sa');
     client.del('sb');
     client.del('sc');
-    
+
     client.sadd('sa', 'a', require_number(1, name));
     client.sadd('sa', 'b', require_number(1, name));
     client.sadd('sa', 'c', require_number(1, name));
@@ -942,11 +1190,11 @@ tests.SINTERSTORE = function () {
 
 tests.SUNION = function () {
     var name = "SUNION";
-    
+
     client.del('sa');
     client.del('sb');
     client.del('sc');
-    
+
     client.sadd('sa', 'a', require_number(1, name));
     client.sadd('sa', 'b', require_number(1, name));
     client.sadd('sa', 'c', require_number(1, name));
@@ -970,12 +1218,12 @@ tests.SUNION = function () {
 
 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));
@@ -1012,7 +1260,7 @@ tests.SORT = function () {
 
     client.del('y');
     client.del('x');
-    
+
     client.rpush('y', 'd', require_number(1, name));
     client.rpush('y', 'b', require_number(2, name));
     client.rpush('y', 'a', require_number(3, name));
@@ -1121,18 +1369,53 @@ tests.SORT = function () {
         assert.deepEqual(buffers_to_strings(values), ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'], name);
         next(name);
     });
-    
+
     // TODO - sort by hash value
 };
 
+tests.MONITOR = function () {
+    var name = "MONITOR", responses = [], monitor_client;
+
+    monitor_client = redis.createClient();
+    monitor_client.monitor(function (err, res) {
+        client.mget("some", "keys", "foo", "bar");
+        client.set("json", JSON.stringify({
+            foo: "123",
+            bar: "sdflkdfsjk",
+            another: false
+        }));
+    });
+    monitor_client.on("monitor", function (time, args) {
+        // skip monitor command for Redis <= 2.4.16
+        if (args[0] === "monitor") return;
+
+        responses.push(args);
+        if (responses.length === 2) {
+            assert.strictEqual(5, responses[0].length);
+            assert.strictEqual("mget", responses[0][0]);
+            assert.strictEqual("some", responses[0][1]);
+            assert.strictEqual("keys", responses[0][2]);
+            assert.strictEqual("foo", responses[0][3]);
+            assert.strictEqual("bar", responses[0][4]);
+            assert.strictEqual(3, responses[1].length);
+            assert.strictEqual("set", responses[1][0]);
+            assert.strictEqual("json", responses[1][1]);
+            assert.strictEqual('{"foo":"123","bar":"sdflkdfsjk","another":false}', responses[1][2]);
+            monitor_client.quit(function (err, res) {
+                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) {
@@ -1145,7 +1428,7 @@ tests.BLPOP = function () {
 
 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) {
@@ -1175,6 +1458,107 @@ tests.TTL = function () {
     }, 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)));
+};
+
+tests.HMSET_THROWS_ON_NON_STRINGS = function () {
+    var name = "HMSET_THROWS_ON_NON_STRINGS";
+    var hash = name;
+    var data = { "a": [ "this is not a string" ] };
+
+    client.hmset(hash, data, cb);
+    function cb(e, r) {
+        assert(e); // should be an error!
+    }
+
+    // alternative way it throws
+    function thrower() {
+        client.hmset(hash, data);
+    }
+    assert.throws(thrower);
+    next(name);
+};
+
+tests.ENABLE_OFFLINE_QUEUE_TRUE = function () {
+    var name = "ENABLE_OFFLINE_QUEUE_TRUE";
+    var cli = redis.createClient(9999, null, {
+        max_attempts: 1
+        // default :)
+        // enable_offline_queue: true
+    });
+    cli.on('error', function(e) {
+        // ignore, b/c expecting a "can't connect" error
+    });
+    return setTimeout(function() {
+        cli.set(name, name, function(err, result) {
+            assert.ifError(err);
+        });
+
+        return setTimeout(function(){
+            assert.strictEqual(cli.offline_queue.length, 1);
+            return next(name);
+        }, 25);
+    }, 50);
+};
+
+tests.ENABLE_OFFLINE_QUEUE_FALSE = function () {
+    var name = "ENABLE_OFFLINE_QUEUE_FALSE";
+    var cli = redis.createClient(9999, null, {
+        max_attempts: 1,
+        enable_offline_queue: false
+    });
+    cli.on('error', function() {
+        // ignore, see above
+    });
+    assert.throws(function () {
+        cli.set(name, name)
+    })
+    assert.doesNotThrow(function () {
+        cli.set(name, name, function (err) {
+            // should callback with an error
+            assert.ok(err);
+            setTimeout(function () {
+                next(name);
+            }, 50);
+        });
+    });
+};
+
+// TODO - need a better way to test auth, maybe auto-config a local Redis server or something.
+// Yes, this is the real password.  Please be nice, thanks.
+tests.auth = function () {
+    var name = "AUTH", client4, ready_count = 0;
+
+    client4 = redis.createClient(9006, "filefish.redistogo.com");
+    client4.auth("664b1b6aaf134e1ec281945a8de702a9", function (err, res) {
+        assert.strictEqual(null, err, name);
+        assert.strictEqual("OK", res.toString(), name);
+    });
+
+    // test auth, then kill the connection so it'll auto-reconnect and auto-re-auth
+    client4.on("ready", function () {
+        ready_count++;
+        if (ready_count === 1) {
+            client4.stream.destroy();
+        } else {
+            client4.quit(function (err, res) {
+                next(name);
+            });
+        }
+    });
+};
+
 all_tests = Object.keys(tests);
 all_start = new Date();
 test_count = 0;
@@ -1190,14 +1574,12 @@ run_next_test = function run_next_test() {
         console.log('\n  completed \x1b[32m%d\x1b[0m tests in \x1b[33m%d\x1b[0m ms\n', test_count, new Date() - all_start);
         client.quit();
         client2.quit();
-        client4.quit();
     }
 };
 
-console.log("Using reply parser " + client.reply_parser.name);
-
 client.once("ready", function start_tests() {
     console.log("Connected to " + client.host + ":" + client.port + ", Redis server version " + client.server_info.redis_version + "\n");
+    console.log("Using reply parser " + client.reply_parser.name);
 
     run_next_test();
 
@@ -1208,17 +1590,6 @@ client.on('end', function () {
     ended = true;
 });
 
-// TODO - need a better way to test auth, maybe auto-config a local Redis server?  Sounds hard.
-// Yes, this is the real password.  Please be nice, thanks.
-client4.auth("664b1b6aaf134e1ec281945a8de702a9", function (err, res) {
-    var name = "AUTH_4";
-
-    if (err) {
-        assert.fail(err, name);
-    }
-    assert.strictEqual("OK", res.toString(), "auth");
-});
-
 // Exit immediately on connection failure, which triggers "exit", below, which fails the test
 client.on("error", function (err) {
     console.error("client: " + err.stack);
@@ -1232,9 +1603,8 @@ client3.on("error", function (err) {
     console.error("client3: " + err.stack);
     process.exit();
 });
-
 client.on("reconnecting", function (params) {
-//    console.log("reconnecting: " + util.inspect(params));
+    console.log("reconnecting: " + util.inspect(params));
 });
 
 process.on('uncaughtException', function (err) {