v.2.6.0-2 pre-release

Author: BridgeAR

.github/ISSUE_TEMPLATE.md

@@ -9,7 +9,7 @@ to a small test case, but it's highly appreciated to have as much data as possib
 Thank you!_
 
 * **Version**: What node_redis and what redis version is the issue happening on?
-* **Platform**: What platform / version? (For example Node.js 0.10 or Node.js 5.7.0)
+* **Platform**: What platform / version? (For example Node.js 0.10 or Node.js 5.7.0 on Windows 7 / Ubuntu 15.10 / Azure)
 * **Description**: Description of your issue, stack traces from errors and code that reproduces the issue
 
 [gitter]: https://gitter.im/NodeRedis/node_redis?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge

README.md

@@ -12,9 +12,7 @@ Install with:
 
     npm install redis
 
-## Usage
-
-Simple example, included as `examples/simple.js`:
+## Usage Example
 
 ```js
 var redis = require("redis"),
@@ -51,6 +49,8 @@ This will display:
     mjr:~/work/node_redis (master)$
 
 Note that the API is entirely asynchronous. To get data back from the server, you'll need to use a callback.
+From v.2.6 on the API supports camelCase and snack_case and all options / variables / events etc. can be used either way.
+It is recommended to use camelCase as this is the default for the Node.js landscape.
 
 ### Promises
 
@@ -83,7 +83,7 @@ return client.multi().get('foo').execAsync().then(function(res) {
 Each Redis command is exposed as a function on the `client` object.
 All functions take either an `args` Array plus optional `callback` Function or
 a variable number of individual arguments followed by an optional callback.
-Here are examples how to use the api:
+Examples:
 
 ```js
 client.hmset(["key", "test keys 1", "test val 1", "test keys 2", "test val 2"], function (err, res) {});
@@ -111,8 +111,6 @@ client.get("missingkey", function(err, reply) {
 
 For a list of Redis commands, see [Redis Command Reference](http://redis.io/commands)
 
-The commands can be specified in uppercase or lowercase for convenience. `client.get()` is the same as `client.GET()`.
-
 Minimal parsing is done on the replies. Commands that return a integer return JavaScript Numbers, arrays return JavaScript Array. `HGETALL` returns an Object keyed by the hash keys. All strings will either be returned as string or as buffer depending on your setting.
 Please be aware that sending null, undefined and Boolean values will result in the value coerced to a string!
 
@@ -139,6 +137,7 @@ are passed an object containing `delay` (in ms) and `attempt` (the attempt #) at
 ### "error"
 
 `client` will emit `error` when encountering an error connecting to the Redis server or when any other in node_redis occurs.
+If you use a command without callback and encounter a ReplyError it is going to be emitted to the error listener.
 
 So please attach the error listener to node_redis.
 
@@ -182,7 +181,7 @@ __Tip:__ If the Redis server runs on the same machine as the client consider usi
 | host      | 127.0.0.1 | IP address of the Redis server |
 | port      | 6379      | Port of the Redis server |
 | path      | null      | The UNIX socket string of the Redis server |
-| url       | null      | The URL of the Redis server. Format: `[redis:]//[user][:password@][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]` (More info avaliable at [IANA](http://www.iana.org/assignments/uri-schemes/prov/redis)). |
+| url       | null      | The URL of the Redis server. Format: `[redis:]//[[user][:password@]][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]` (More info avaliable at [IANA](http://www.iana.org/assignments/uri-schemes/prov/redis)). |
 | parser    | hiredis   |  If hiredis is not installed, automatic fallback to the built-in javascript parser |
 | string_numbers | null   | Set to `true`, `node_redis` will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above `Number.MAX_SAFE_INTEGER === 2^53`). Hiredis is incapable of this behavior, so setting this option to `true` will result in the built-in javascript parser being used no matter the value of the `parser` option. |
 | return_buffers | false | If set to `true`, then all replies will be sent to callbacks as Buffers instead of Strings. |
@@ -295,6 +294,51 @@ client.get("foo_rand000000000000", function (err, reply) {
 
 `client.end()` without the flush parameter set to true should NOT be used in production!
 
+## Error handling (>= v.2.6)
+
+All redis errors are returned as `ReplyError`.
+All unresolved commands that get rejected due to what ever reason return a `AbortError`.
+As subclass of the `AbortError` a `AggregateError` exists. This is emitted in case multiple unresolved commands without callback got rejected in debug_mode.
+They are all aggregated and a single error is emitted in that case.
+
+Example:
+```js
+var redis = require('./');
+var assert = require('assert');
+var client = redis.createClient();
+
+client.on('error', function (err) {
+    assert(err instanceof Error);
+    assert(err instanceof redis.AbortError);
+    assert(err instanceof redis.AggregateError);
+    assert.strictEqual(err.errors.length, 2); // The set and get got aggregated in here
+    assert.strictEqual(err.code, 'NR_CLOSED');
+});
+client.set('foo', 123, 'bar', function (err, res) { // To many arguments
+    assert(err instanceof redis.ReplyError); // => true
+    assert.strictEqual(err.command, 'SET');
+    assert.deepStrictEqual(err.args, ['foo', 123, 'bar']);
+
+    redis.debug_mode = true;
+    client.set('foo', 'bar');
+    client.get('foo');
+    process.nextTick(function () {
+        client.end(true); // Force closing the connection while the command did not yet return
+        redis.debug_mode = false;
+    });
+});
+
+```
+
+Every `ReplyError` contains the `command` name in all-caps and the arguments (`args`).
+
+If node_redis emits a library error because of another error, the triggering error is added to the returned error as `origin` attribute.
+
+___Error codes___
+
+node_redis returns a `NR_CLOSED` error code if the clients connection dropped. If a command unresolved command got rejected a `UNERCTAIN_STATE` code is returned.
+A `CONNECTION_BROKEN` error code is used in case node_redis gives up to reconnect.
+
 ## client.unref()
 
 Call `unref()` on the underlying socket connection to the Redis server, allowing the program to exit once no more commands are pending.
@@ -363,7 +407,7 @@ client.HMSET(key1, "0123456789", "abcdefghij", "some manner of key", "a type of
 
 ## Publish / Subscribe
 
-Here is a simple example of the API for publish / subscribe. This program opens two
+Example of the publish / subscribe API. This program opens two
 client connections, subscribes to a channel on one of them, and publishes to that
 channel on the other:
 
@@ -412,6 +456,16 @@ Client will emit `pmessage` for every message received that matches an active su
 Listeners are passed the original pattern used with `PSUBSCRIBE` as `pattern`, the sending channel
 name as `channel`, and the message as `message`.
 
+### "message_buffer" (channel, message)
+
+This is the same as the `message` event with the exception, that it is always going to emit a buffer.
+If you listen to the `message` event at the same time as the `message_buffer`, it is always going to emit a string.
+
+### "pmessage_buffer" (pattern, channel, message)
+
+This is the same as the `pmessage` event with the exception, that it is always going to emit a buffer.
+If you listen to the `pmessage` event at the same time as the `pmessage_buffer`, it is always going to emit a string.
+
 ### "subscribe" (channel, count)
 
 Client will emit `subscribe` in response to a `SUBSCRIBE` command. Listeners are passed the
@@ -529,7 +583,7 @@ Redis. The interface in `node_redis` is to return an individual `Batch` object b
 The only difference between .batch and .multi is that no transaction is going to be used.
 Be aware that the errors are - just like in multi statements - in the result. Otherwise both, errors and results could be returned at the same time.
 
-If you fire many commands at once this is going to **boost the execution speed by up to 400%** [sic!] compared to fireing the same commands in a loop without waiting for the result! See the benchmarks for further comparison. Please remember that all commands are kept in memory until they are fired.
+If you fire many commands at once this is going to boost the execution speed significantly compared to fireing the same commands in a loop without waiting for the result! See the benchmarks for further comparison. Please remember that all commands are kept in memory until they are fired.
 
 ## Monitor mode
 
@@ -539,7 +593,7 @@ across all client connections, including from other client libraries and other c
 A `monitor` event is going to be emitted for every command fired from any client connected to the server including the monitoring client itself.
 The callback for the `monitor` event takes a timestamp from the Redis server, an array of command arguments and the raw monitoring string.
 
-Here is a simple example:
+Example:
 
 ```js
 var client  = require("redis").createClient();
@@ -599,9 +653,10 @@ the second word as first parameter:
     client.multi().script('load', 'return 1').exec(...);
     client.multi([['script', 'load', 'return 1']]).exec(...);
 
-## client.duplicate([options])
+## client.duplicate([options][, callback])
 
 Duplicate all current options and return a new redisClient instance. All options passed to the duplicate function are going to replace the original option.
+If you pass a callback, duplicate is going to wait until the client is ready and returns it in the callback. If an error occurs in the meanwhile, that is going to return an error instead in the callback.
 
 ## client.send_command(command_name[, [args][, callback]])
 
@@ -615,27 +670,16 @@ All commands are sent as multi-bulk commands. `args` can either be an Array of a
 
 Boolean tracking the state of the connection to the Redis server.
 
-## client.command_queue.length
+## client.command_queue_length
 
 The number of commands that have been sent to the Redis server but not yet replied to. You can use this to
 enforce some kind of maximum queue depth for commands while connected.
 
-Don't mess with `client.command_queue` though unless you really know what you are doing.
-
-## client.offline_queue.length
+## client.offline_queue_length
 
 The number of commands that have been queued up for a future connection. You can use this to enforce
 some kind of maximum queue depth for pre-connection commands.
 
-## client.retry_delay
-
-Current delay in milliseconds before a connection retry will be attempted. This starts at `200`.
-
-## client.retry_backoff
-
-Multiplier for future retry timeouts. This should be larger than 1 to add more time between retries.
-Defaults to 1.7. The default initial connection retry is 200, so the second retry will be 340, followed by 578, etc.
-
 ### Commands with Optional and Keyword arguments
 
 This applies to anything that uses an optional `[WITHSCORES]` or `[LIMIT offset count]` in the [redis.io/commands](http://redis.io/commands) documentation.

benchmarks/multi_bench.js

@@ -23,6 +23,7 @@ function returnArg (name, def) {
 }
 var num_clients = returnArg('clients', 1);
 var run_time = returnArg('time', 2500); // ms
+var pipeline = returnArg('pipeline', 1); // number of concurrent commands
 var versions_logged = false;
 var client_options = {
     parser: returnArg('parser', 'hiredis'),
@@ -41,17 +42,18 @@ function lpad (input, len, chr) {
 
 metrics.Histogram.prototype.print_line = function () {
     var obj = this.printObj();
-    return lpad((obj.min / 1e6).toFixed(2), 6) + '/' + lpad((obj.max / 1e6).toFixed(2), 6) + '/' + lpad((obj.mean / 1e6).toFixed(2), 6);
+    return lpad((obj.mean / 1e6).toFixed(2), 6) + '/' + lpad((obj.max / 1e6).toFixed(2), 6);
 };
 
 function Test (args) {
     this.args = args;
+    this.args.pipeline = +pipeline;
     this.callback = null;
     this.clients = [];
     this.clients_ready = 0;
     this.commands_sent = 0;
     this.commands_completed = 0;
-    this.max_pipeline = this.args.pipeline || 50;
+    this.max_pipeline = +pipeline;
     this.batch_pipeline = this.args.batch || 0;
     this.client_options = args.client_options || {};
     this.client_options.parser = client_options.parser;
@@ -206,7 +208,7 @@ Test.prototype.print_stats = function () {
     var duration = Date.now() - this.test_start;
     totalTime += duration;
 
-    console.log('min/max/avg: ' + this.command_latency.print_line() + ' ' + lpad(duration, 6) + 'ms total, ' +
+    console.log('avg/max: ' + this.command_latency.print_line() + lpad(duration, 5) + 'ms total, ' +
         lpad(Math.round(this.commands_completed / (duration / 1000)), 7) + ' ops/sec');
 };
 
@@ -217,55 +219,55 @@ large_buf = new Buffer(large_str);
 very_large_str = (new Array((4 * 1024 * 1024) + 1).join('-'));
 very_large_buf = new Buffer(very_large_str);
 
-tests.push(new Test({descr: 'PING', command: 'ping', args: [], pipeline: 1}));
+tests.push(new Test({descr: 'PING', command: 'ping', args: []}));
 tests.push(new Test({descr: 'PING', command: 'ping', args: [], batch: 50}));
 
-tests.push(new Test({descr: 'SET 4B str', command: 'set', args: ['foo_rand000000000000', small_str], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4B str', command: 'set', args: ['foo_rand000000000000', small_str]}));
 tests.push(new Test({descr: 'SET 4B str', command: 'set', args: ['foo_rand000000000000', small_str], batch: 50}));
 
-tests.push(new Test({descr: 'SET 4B buf', command: 'set', args: ['foo_rand000000000000', small_buf], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4B buf', command: 'set', args: ['foo_rand000000000000', small_buf]}));
 tests.push(new Test({descr: 'SET 4B buf', command: 'set', args: ['foo_rand000000000000', small_buf], batch: 50}));
 
-tests.push(new Test({descr: 'GET 4B str', command: 'get', args: ['foo_rand000000000000'], pipeline: 1}));
+tests.push(new Test({descr: 'GET 4B str', command: 'get', args: ['foo_rand000000000000']}));
 tests.push(new Test({descr: 'GET 4B str', command: 'get', args: ['foo_rand000000000000'], batch: 50}));
 
-tests.push(new Test({descr: 'GET 4B buf', command: 'get', args: ['foo_rand000000000000'], pipeline: 1, client_opts: { return_buffers: true} }));
+tests.push(new Test({descr: 'GET 4B buf', command: 'get', args: ['foo_rand000000000000'], client_opts: { return_buffers: true} }));
 tests.push(new Test({descr: 'GET 4B buf', command: 'get', args: ['foo_rand000000000000'], batch: 50, client_opts: { return_buffers: true} }));
 
-tests.push(new Test({descr: 'SET 4KiB str', command: 'set', args: ['foo_rand000000000001', large_str], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4KiB str', command: 'set', args: ['foo_rand000000000001', large_str]}));
 tests.push(new Test({descr: 'SET 4KiB str', command: 'set', args: ['foo_rand000000000001', large_str], batch: 50}));
 
-tests.push(new Test({descr: 'SET 4KiB buf', command: 'set', args: ['foo_rand000000000001', large_buf], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4KiB buf', command: 'set', args: ['foo_rand000000000001', large_buf]}));
 tests.push(new Test({descr: 'SET 4KiB buf', command: 'set', args: ['foo_rand000000000001', large_buf], batch: 50}));
 
-tests.push(new Test({descr: 'GET 4KiB str', command: 'get', args: ['foo_rand000000000001'], pipeline: 1}));
+tests.push(new Test({descr: 'GET 4KiB str', command: 'get', args: ['foo_rand000000000001']}));
 tests.push(new Test({descr: 'GET 4KiB str', command: 'get', args: ['foo_rand000000000001'], batch: 50}));
 
-tests.push(new Test({descr: 'GET 4KiB buf', command: 'get', args: ['foo_rand000000000001'], pipeline: 1, client_opts: { return_buffers: true} }));
+tests.push(new Test({descr: 'GET 4KiB buf', command: 'get', args: ['foo_rand000000000001'], client_opts: { return_buffers: true} }));
 tests.push(new Test({descr: 'GET 4KiB buf', command: 'get', args: ['foo_rand000000000001'], batch: 50, client_opts: { return_buffers: true} }));
 
-tests.push(new Test({descr: 'INCR', command: 'incr', args: ['counter_rand000000000000'], pipeline: 1}));
+tests.push(new Test({descr: 'INCR', command: 'incr', args: ['counter_rand000000000000']}));
 tests.push(new Test({descr: 'INCR', command: 'incr', args: ['counter_rand000000000000'], batch: 50}));
 
-tests.push(new Test({descr: 'LPUSH', command: 'lpush', args: ['mylist', small_str], pipeline: 1}));
+tests.push(new Test({descr: 'LPUSH', command: 'lpush', args: ['mylist', small_str]}));
 tests.push(new Test({descr: 'LPUSH', command: 'lpush', args: ['mylist', small_str], batch: 50}));
 
-tests.push(new Test({descr: 'LRANGE 10', command: 'lrange', args: ['mylist', '0', '9'], pipeline: 1}));
+tests.push(new Test({descr: 'LRANGE 10', command: 'lrange', args: ['mylist', '0', '9']}));
 tests.push(new Test({descr: 'LRANGE 10', command: 'lrange', args: ['mylist', '0', '9'], batch: 50}));
 
-tests.push(new Test({descr: 'LRANGE 100', command: 'lrange', args: ['mylist', '0', '99'], pipeline: 1}));
+tests.push(new Test({descr: 'LRANGE 100', command: 'lrange', args: ['mylist', '0', '99']}));
 tests.push(new Test({descr: 'LRANGE 100', command: 'lrange', args: ['mylist', '0', '99'], batch: 50}));
 
-tests.push(new Test({descr: 'SET 4MiB str', command: 'set', args: ['foo_rand000000000002', very_large_str], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4MiB str', command: 'set', args: ['foo_rand000000000002', very_large_str]}));
 tests.push(new Test({descr: 'SET 4MiB str', command: 'set', args: ['foo_rand000000000002', very_large_str], batch: 20}));
 
-tests.push(new Test({descr: 'SET 4MiB buf', command: 'set', args: ['foo_rand000000000002', very_large_buf], pipeline: 1}));
+tests.push(new Test({descr: 'SET 4MiB buf', command: 'set', args: ['foo_rand000000000002', very_large_buf]}));
 tests.push(new Test({descr: 'SET 4MiB buf', command: 'set', args: ['foo_rand000000000002', very_large_buf], batch: 20}));
 
-tests.push(new Test({descr: 'GET 4MiB str', command: 'get', args: ['foo_rand000000000002'], pipeline: 1}));
+tests.push(new Test({descr: 'GET 4MiB str', command: 'get', args: ['foo_rand000000000002']}));
 tests.push(new Test({descr: 'GET 4MiB str', command: 'get', args: ['foo_rand000000000002'], batch: 20}));
 
-tests.push(new Test({descr: 'GET 4MiB buf', command: 'get', args: ['foo_rand000000000002'], pipeline: 1, client_opts: { return_buffers: true} }));
+tests.push(new Test({descr: 'GET 4MiB buf', command: 'get', args: ['foo_rand000000000002'], client_opts: { return_buffers: true} }));
 tests.push(new Test({descr: 'GET 4MiB buf', command: 'get', args: ['foo_rand000000000002'], batch: 20, client_opts: { return_buffers: true} }));
 
 function next () {

changelog.md

@@ -1,6 +1,43 @@
 Changelog
 =========
 
+## v.2.6.0-2 - xx Apr, 2016
+
+Features
+
+-  Added support for the new `CLIENT REPLY ON|OFF|SKIP` command (Redis v.3.2)
+-  Added support for camelCase
+ -  The Node.js landscape default is to use camelCase. node_redis is a bit out of the box here
+    but from now on it is possible to use both, just as you prefer!
+ -  If there's any documented variable missing as camelCased, please open a issue for it
+-  Improve error handling significantly
+ -  Only emit an error if the error has not already been handled in a callback
+ -  Emit an error if a command would otherwise silently fail (no callback present)
+ -  Improved unspecific error messages e.g. "Connection gone from end / close event"
+ -  Added `args` to command errors to improve identification of the error
+ -  Added origin to errors if there's e.g. a connection error
+ -  Added ReplyError class. All Redis errors are from now on going to be of that class
+ -  Added AbortError class. A subclass of AbortError. All unresolved and by node_redis rejected commands are from now on of that class
+ -  Added AggregateError class. If a unresolved and by node_redis rejected command has no callback and
+    this applies to more than a single command, the errors for the commands without callback are aggregated
+    to a single error that is emitted in debug_mode in that case.
+-  Added `message_buffer` / `pmessage_buffer` events. That event is always going to emit a buffer
+ -  Listening to the `message` event at the same time is always going to return the same message as string
+-  Added callback option to the duplicate function
+-  Added support for `__proto__` and other reserved keywords as hgetall field
+-  Updated [redis-commands](https://github.com/NodeRedis/redis-commands) dependency ([changelog](https://github.com/NodeRedis/redis-commands/releases/tag/v.1.2.0))
+
+Bugfixes
+
+-  Fixed v.2.5.0 auth command regression (under special circumstances a reconnect would not authenticate properly)
+-  Fixed v.2.6.0-0 pub sub mode and quit command regressions:
+ -  Entering pub sub mode not working if a earlier called and still running command returned an error
+ -  Unsubscribe callback not called if unsubscribing from all channels and resubscribing right away
+ -  Quit command resulting in an error in some cases
+-  Fixed special handled functions in batch and multi context not working the same as without (e.g. select and info)
+ -  Be aware that not all commands work in combination with transactions but they all work with batch
+-  Fixed address always set to 127.0.0.1:6379 in case host / port is set in the `tls` options instead of the general options
+
 ## v.2.6.0-1 - 01 Apr, 2016
 
 A second pre-release with further fixes. This is likely going to be released as 2.6.0 stable without further changes.

index.js

@@ -2,18 +2,18 @@
 
 // This Command constructor is ever so slightly faster than using an object literal, but more importantly, using
 // a named constructor helps it show up meaningfully in the V8 CPU profiler and in heap snapshots.
-function Command (command, args, callback) {
+function Command (command, args, buffer_args, callback) {
     this.command = command;
-    this.args = args; // We only need the args for the offline commands => move them into another class. We need the number of args though for pub sub
-    this.buffer_args = false;
+    this.args = args;
+    this.buffer_args = buffer_args;
     this.callback = callback;
-    this.sub_commands_left = args.length;
 }
 
-function OfflineCommand (command, args, callback) {
+function OfflineCommand (command, args, callback, call_on_write) {
     this.command = command;
     this.args = args;
     this.callback = callback;
+    this.call_on_write = call_on_write;
 }
 
 module.exports = {

lib/command.js

@@ -12,7 +12,7 @@ module.exports = function createClient (port_arg, host_arg, options) {
             host = host_arg;
         } else {
             if (options && host_arg) {
-                throw new Error('Unknown type of connection in createClient()');
+                throw new TypeError('Unknown type of connection in createClient()');
             }
             options = options || host_arg;
         }
@@ -44,20 +44,20 @@ module.exports = function createClient (port_arg, host_arg, options) {
             }
             if (parsed.search !== '') {
                 var elem;
-                for (elem in parsed.query) { // jshint ignore: line
+                for (elem in parsed.query) {
                     // If options are passed twice, only the parsed options will be used
                     if (elem in options) {
                         if (options[elem] === parsed.query[elem]) {
                             console.warn('node_redis: WARNING: You passed the ' + elem + ' option twice!');
                         } else {
-                            throw new Error('The ' + elem + ' option is added twice and does not match');
+                            throw new RangeError('The ' + elem + ' option is added twice and does not match');
                         }
                     }
                     options[elem] = parsed.query[elem];
                 }
             }
         } else if (parsed.hostname) {
-            throw new Error('The redis url must begin with slashes "//" or contain slashes after the redis protocol');
+            throw new RangeError('The redis url must begin with slashes "//" or contain slashes after the redis protocol');
         } else {
             options.path = port_arg;
         }
@@ -67,12 +67,12 @@ module.exports = function createClient (port_arg, host_arg, options) {
         options.host = options.host || host_arg;
 
         if (port_arg && arguments.length !== 1) {
-            throw new Error('To many arguments passed to createClient. Please only pass the options object');
+            throw new TypeError('To many arguments passed to createClient. Please only pass the options object');
         }
     }
 
     if (!options) {
-        throw new Error('Unknown type of connection in createClient()');
+        throw new TypeError('Unknown type of connection in createClient()');
     }
 
     return options;

lib/createClient.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var util = require('util');
+
+function AbortError (obj) {
+    Error.captureStackTrace(this, this.constructor);
+    var message;
+    Object.defineProperty(this, 'name', {
+        get: function () {
+            return this.constructor.name;
+        }
+    });
+    Object.defineProperty(this, 'message', {
+        get: function () {
+            return message;
+        },
+        set: function (msg) {
+            message = msg;
+        }
+    });
+    for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
+        this[key] = obj[key];
+    }
+    // Explicitly add the message
+    // If the obj is a error itself, the message is not enumerable
+    this.message = obj.message;
+}
+
+function ReplyError (obj) {
+    Error.captureStackTrace(this, this.constructor);
+    var tmp;
+    Object.defineProperty(this, 'name', {
+        get: function () {
+            return this.constructor.name;
+        }
+    });
+    Object.defineProperty(this, 'message', {
+        get: function () {
+            return tmp;
+        },
+        set: function (msg) {
+            tmp = msg;
+        }
+    });
+    this.message = obj.message;
+}
+
+function AggregateError (obj) {
+    Error.captureStackTrace(this, this.constructor);
+    var tmp;
+    Object.defineProperty(this, 'name', {
+        get: function () {
+            return this.constructor.name;
+        }
+    });
+    Object.defineProperty(this, 'message', {
+        get: function () {
+            return tmp;
+        },
+        set: function (msg) {
+            tmp = msg;
+        }
+    });
+    for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
+        this[key] = obj[key];
+    }
+    this.message = obj.message;
+}
+
+util.inherits(ReplyError, Error);
+util.inherits(AbortError, Error);
+util.inherits(AggregateError, AbortError);
+
+module.exports = {
+    ReplyError: ReplyError,
+    AbortError: AbortError,
+    AggregateError: AggregateError
+};

lib/customErrors.js

@@ -2,9 +2,9 @@
 
 var index = require('../');
 
-function debug (msg) {
+function debug () {
     if (index.debug_mode) {
-        console.error(msg);
+        console.error.apply(null, arguments);
     }
 }
 

lib/debug.js

@@ -10,10 +10,10 @@ All documented and exposed API belongs in here
 **********************************************/
 
 // Redirect calls to the appropriate function and use to send arbitrary / not supported commands
-RedisClient.prototype.send_command = function (command, args, callback) {
+RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = function (command, args, callback) {
     // Throw to fail early instead of relying in order in this case
     if (typeof command !== 'string') {
-        throw new Error('Wrong input type "' + (command !== null && command !== undefined ? command.constructor.name : command) + '" for command name');
+        throw new TypeError('Wrong input type "' + (command !== null && command !== undefined ? command.constructor.name : command) + '" for command name');
     }
     if (!Array.isArray(args)) {
         if (args === undefined || args === null) {
@@ -22,11 +22,11 @@ RedisClient.prototype.send_command = function (command, args, callback) {
             callback = args;
             args = [];
         } else {
-            throw new Error('Wrong input type "' + args.constructor.name + '" for args');
+            throw new TypeError('Wrong input type "' + args.constructor.name + '" for args');
         }
     }
     if (typeof callback !== 'function' && callback !== undefined) {
-        throw new Error('Wrong input type "' + (callback !== null ? callback.constructor.name : 'null') + '" for callback function');
+        throw new TypeError('Wrong input type "' + (callback !== null ? callback.constructor.name : 'null') + '" for callback function');
     }
 
     // Using the raw multi command is only possible with this function
@@ -39,15 +39,18 @@ RedisClient.prototype.send_command = function (command, args, callback) {
         return this.internal_send_command(command, args, callback);
     }
     if (typeof callback === 'function') {
-        args = args.concat([callback]);
+        args = args.concat([callback]); // Prevent manipulating the input array
     }
     return this[command].apply(this, args);
 };
 
 RedisClient.prototype.end = function (flush) {
     // Flush queue if wanted
     if (flush) {
-        this.flush_and_error(new Error("The command can't be processed. The connection has already been closed."));
+        this.flush_and_error({
+            message: 'Connection forcefully ended and command aborted.',
+            code: 'NR_CLOSED'
+        });
     } else if (arguments.length === 0) {
         this.warn(
             'Using .end() without the flush parameter is deprecated and throws from v.3.0.0 on.\n' +
@@ -79,13 +82,30 @@ RedisClient.prototype.unref = function () {
     }
 };
 
-RedisClient.prototype.duplicate = function (options) {
+RedisClient.prototype.duplicate = function (options, callback) {
+    if (typeof options === 'function') {
+        callback = options;
+        options = null;
+    }
     var existing_options = utils.clone(this.options);
     options = utils.clone(options);
-    for (var elem in options) { // jshint ignore: line
+    for (var elem in options) {
         existing_options[elem] = options[elem];
     }
     var client = new RedisClient(existing_options);
     client.selected_db = this.selected_db;
+    if (typeof callback === 'function') {
+        var ready_listener = function () {
+            callback(null, client);
+            client.removeAllListeners(error_listener);
+        };
+        var error_listener = function (err) {
+            callback(err);
+            client.end(true);
+        };
+        client.once('ready', ready_listener);
+        client.once('error', error_listener);
+        return;
+    }
     return client;
 };

lib/extendedApi.js

@@ -20,47 +20,11 @@ function Multi (client, args) {
     }
 }
 
-Multi.prototype.hmset = Multi.prototype.HMSET = function hmset () {
-    var arr,
-        len = 0,
-        callback,
-        i = 0;
-    if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
-        callback = arguments[1];
-    } else if (Array.isArray(arguments[1])) {
-        len = arguments[1].length;
-        arr = new Array(len + 1);
-        arr[0] = arguments[0];
-        for (; i < len; i += 1) {
-            arr[i + 1] = arguments[1][i];
-        }
-        callback = arguments[2];
-    } else if (typeof arguments[1] === 'object' && (typeof arguments[2] === 'function' || typeof arguments[2] === 'undefined')) {
-        arr = [arguments[0]];
-        for (var field in arguments[1]) { // jshint ignore: line
-            arr.push(field, arguments[1][field]);
-        }
-        callback = arguments[2];
-    } else {
-        len = arguments.length;
-        // The later should not be the average use case
-        if (len !== 0 && (typeof arguments[len - 1] === 'function' || typeof arguments[len - 1] === 'undefined')) {
-            len--;
-            callback = arguments[len];
-        }
-        arr = new Array(len);
-        for (; i < len; i += 1) {
-            arr[i] = arguments[i];
-        }
-    }
-    this.queue.push(['hmset', arr, callback]);
-    return this;
-};
-
-function pipeline_transaction_command (self, command, args, index, cb) {
+function pipeline_transaction_command (self, command, args, index, cb, call_on_write) {
+    // Queueing is done first, then the commands are executed
     self._client.send_command(command, args, function (err, reply) {
-        if (err) {
+        // Ignore the multi command. This is applied by node_redis and the user does not benefit by it
+        if (err && index !== -1) {
             if (cb) {
                 cb(err);
             }
@@ -70,7 +34,7 @@ function pipeline_transaction_command (self, command, args, index, cb) {
     });
 }
 
-Multi.prototype.exec_atomic = function exec_atomic (callback) {
+Multi.prototype.exec_atomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.execAtomic = function exec_atomic (callback) {
     if (this.queue.length < 2) {
         return this.exec_batch(callback);
     }
@@ -81,13 +45,11 @@ function multi_callback (self, err, replies) {
     var i = 0, args;
 
     if (err) {
-        // The errors would be circular
-        var connection_error = ['CONNECTION_BROKEN', 'UNCERTAIN_STATE'].indexOf(err.code) !== -1;
-        err.errors = connection_error ? [] : self.errors;
+        err.errors = self.errors;
         if (self.callback) {
             self.callback(err);
             // Exclude connection errors so that those errors won't be emitted twice
-        } else if (!connection_error) {
+        } else if (err.code !== 'CONNECTION_BROKEN') {
             self._client.emit('error', err);
         }
         return;
@@ -122,36 +84,45 @@ function multi_callback (self, err, replies) {
 }
 
 Multi.prototype.exec_transaction = function exec_transaction (callback) {
+    if (this.monitoring || this._client.monitoring) {
+        var err = new RangeError(
+            'Using transaction with a client that is in monitor mode does not work due to faulty return values of Redis.'
+        );
+        err.command = 'EXEC';
+        err.code = 'EXECABORT';
+        return utils.reply_in_order(this._client, callback, err);
+    }
     var self = this;
     var len = self.queue.length;
     self.errors = [];
     self.callback = callback;
-    self._client.cork(len + 2);
+    self._client.cork();
     self.wants_buffers = new Array(len);
-    pipeline_transaction_command(self, 'multi', []);
+    pipeline_transaction_command(self, 'multi', [], -1);
     // Drain queue, callback will catch 'QUEUED' or error
     for (var index = 0; index < len; index++) {
-        var args = self.queue.get(index);
-        var command = args[0];
-        var cb = args[2];
+        // The commands may not be shifted off, since they are needed in the result handler
+        var command_obj = self.queue.get(index);
+        var command = command_obj[0];
+        var cb = command_obj[2];
+        var call_on_write = command_obj.length === 4 ? command_obj[3] : undefined;
         // Keep track of who wants buffer responses:
         if (self._client.options.detect_buffers) {
             self.wants_buffers[index] = false;
-            for (var i = 0; i < args[1].length; i += 1) {
-                if (args[1][i] instanceof Buffer) {
+            for (var i = 0; i < command_obj[1].length; i += 1) {
+                if (command_obj[1][i] instanceof Buffer) {
                     self.wants_buffers[index] = true;
                     break;
                 }
             }
         }
-        pipeline_transaction_command(self, command, args[1], index, cb);
+        pipeline_transaction_command(self, command, command_obj[1], index, cb, call_on_write);
     }
 
     self._client.internal_send_command('exec', [], function (err, replies) {
         multi_callback(self, err, replies);
     });
     self._client.uncork();
-    self._client.writeDefault = self._client.writeStrings;
     return !self._client.should_buffer;
 };
 
@@ -172,7 +143,18 @@ Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = funct
     var self = this;
     var len = self.queue.length;
     var index = 0;
-    var args;
+    var command_obj;
+    self._client.cork();
+    if (!callback) {
+        while (command_obj = self.queue.shift()) {
+            self._client.internal_send_command(command_obj[0], command_obj[1], command_obj[2], (command_obj.length === 4 ? command_obj[3] : undefined));
+        }
+        self._client.uncork();
+        return !self._client.should_buffer;
+    } else if (len === 0) {
+        utils.reply_in_order(self._client, callback, null, []);
+        return !self._client.should_buffer;
+    }
     var callback_without_own_cb = function (err, res) {
         if (err) {
             self.results.push(err);
@@ -191,31 +173,23 @@ Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = funct
             callback(null, self.results);
         };
     };
-    if (len === 0) {
-        if (callback) {
-            utils.reply_in_order(self._client, callback, null, []);
-        }
-        return true;
-    }
     self.results = [];
-    self._client.cork(len);
-    while (args = self.queue.shift()) {
-        var command = args[0];
+    while (command_obj = self.queue.shift()) {
+        var command = command_obj[0];
+        var call_on_write = command_obj.length === 4 ? command_obj[3] : undefined;
         var cb;
-        if (typeof args[2] === 'function') {
-            cb = batch_callback(self, args[2], index);
+        if (typeof command_obj[2] === 'function') {
+            cb = batch_callback(self, command_obj[2], index);
         } else {
             cb = callback_without_own_cb;
         }
         if (typeof callback === 'function' && index === len - 1) {
             cb = last_callback(cb);
         }
-        self._client.internal_send_command(command, args[1], cb);
+        this._client.internal_send_command(command, command_obj[1], cb, call_on_write);
         index++;
     }
-    self.queue = new Queue();
     self._client.uncork();
-    self._client.writeDefault = self._client.writeStrings;
     return !self._client.should_buffer;
 };
 

lib/individualCommands.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// Using a predefined object with this prototype is faster than calling `Object.create(null)` directly
+// This is needed to make sure `__proto__` and similar reserved words can be used
+function RawObject () {}
+RawObject.prototype = Object.create(null);
+
+module.exports = RawObject;

lib/multi.js

@@ -1,13 +1,15 @@
 'use strict';
 
+var RawObject = require('./rawObject');
+
 // hgetall converts its replies to an Object. If the reply is empty, null is returned.
-// These function are only called with internal data and have therefor always the same instanceof X
+// These function are only called with internal data and have therefore always the same instanceof X
 function replyToObject (reply) {
     // The reply might be a string or a buffer if this is called in a transaction (multi)
     if (reply.length === 0 || !(reply instanceof Array)) {
         return null;
     }
-    var obj = {};
+    var obj = new RawObject();
     for (var i = 0; i < reply.length; i += 2) {
         obj[reply[i].toString('binary')] = reply[i + 1];
     }
@@ -39,8 +41,10 @@ function print (err, reply) {
     }
 }
 
+var camelCase;
 // Deep clone arbitrary objects with arrays. Can't handle cyclic structures (results in a range error)
 // Any attribute with a non primitive value besides object and array will be passed by reference (e.g. Buffers, Maps, Functions)
+// All capital letters are going to be replaced with a lower case letter and a underscore infront of it
 function clone (obj) {
     var copy;
     if (Array.isArray(obj)) {
@@ -55,15 +59,27 @@ function clone (obj) {
         var elems = Object.keys(obj);
         var elem;
         while (elem = elems.pop()) {
-            copy[elem] = clone(obj[elem]);
+            // Accept camelCase options and convert them to snack_case
+            var snack_case = elem.replace(/[A-Z][^A-Z]/g, '_$&').toLowerCase();
+            // If camelCase is detected, pass it to the client, so all variables are going to be camelCased
+            // There are no deep nested options objects yet, but let's handle this future proof
+            if (snack_case !== elem.toLowerCase()) {
+                camelCase = true;
+            }
+            copy[snack_case] = clone(obj[elem]);
         }
         return copy;
     }
     return obj;
 }
 
 function convenienceClone (obj) {
-    return clone(obj) || {};
+    camelCase = false;
+    obj = clone(obj) || {};
+    if (camelCase) {
+        obj.camel_case = true;
+    }
+    return obj;
 }
 
 function callbackOrEmit (self, callback, err, res) {
@@ -74,8 +90,16 @@ function callbackOrEmit (self, callback, err, res) {
     }
 }
 
-function replyInOrder (self, callback, err, res) {
-    var command_obj = self.command_queue.peekBack() || self.offline_queue.peekBack();
+function replyInOrder (self, callback, err, res, queue) {
+    // If the queue is explicitly passed, use that, otherwise fall back to the offline queue first,
+    // as there might be commands in both queues at the same time
+    var command_obj;
+    /* istanbul ignore if: TODO: Remove this as soon as we test Redis 3.2 on travis */
+    if (queue) {
+        command_obj = queue.peekBack();
+    } else {
+        command_obj = self.offline_queue.peekBack() || self.command_queue.peekBack();
+    }
     if (!command_obj) {
         process.nextTick(function () {
             callbackOrEmit(self, callback, err, res);

lib/rawObject.js

@@ -21,13 +21,12 @@
     "coverage": "nyc report --reporter=html",
     "benchmark": "node benchmarks/multi_bench.js",
     "test": "nyc --cache mocha ./test/*.js ./test/commands/*.js --timeout=8000",
-    "pretest": "optional-dev-dependency hiredis",
     "posttest": "eslint . --fix"
   },
   "dependencies": {
     "double-ended-queue": "^2.1.0-0",
-    "redis-commands": "^1.1.0",
-    "redis-parser": "^1.2.0"
+    "redis-commands": "^1.2.0",
+    "redis-parser": "^1.3.0"
   },
   "engines": {
     "node": ">=0.10.0"
@@ -40,7 +39,6 @@
     "metrics": "^0.1.9",
     "mocha": "^2.3.2",
     "nyc": "^6.0.0",
-    "optional-dev-dependency": "^1.1.0",
     "tcp-port-used": "^0.1.2",
     "uuid": "^2.0.1",
     "win-spawn": "^2.0.0"

lib/utils.js

@@ -53,7 +53,7 @@ describe('client authentication', function () {
                 client.auth(auth, function (err, res) {
                     assert.strictEqual('retry worked', res);
                     var now = Date.now();
-                    // Hint: setTimeout sometimes triggers early and therefor the value can be like one or two ms to early
+                    // Hint: setTimeout sometimes triggers early and therefore the value can be like one or two ms to early
                     assert(now - time >= 98, 'Time should be above 100 ms (the reconnect time) and is ' + (now - time));
                     assert(now - time < 225, 'Time should be below 255 ms (the reconnect should only take a bit above 100 ms) and is ' + (now - time));
                     done();
@@ -160,24 +160,34 @@ describe('client authentication', function () {
                 client.on('ready', done);
             });
 
-            it('reconnects with appropriate authentication', function (done) {
+            it('reconnects with appropriate authentication while offline commands are present', function (done) {
                 if (helper.redisProcess().spawnFailed()) this.skip();
 
                 client = redis.createClient.apply(null, args);
                 client.auth(auth);
                 client.on('ready', function () {
-                    if (this.times_connected === 1) {
-                        client.stream.destroy();
+                    if (this.times_connected < 3) {
+                        var interval = setInterval(function () {
+                            if (client.commandQueueLength !== 0) {
+                                return;
+                            }
+                            clearInterval(interval);
+                            interval = null;
+                            client.stream.destroy();
+                            client.set('foo', 'bar');
+                            client.get('foo'); // Errors would bubble
+                            assert.strictEqual(client.offlineQueueLength, 2);
+                        }, 1);
                     } else {
                         done();
                     }
                 });
                 client.on('reconnecting', function (params) {
-                    assert.strictEqual(params.error.message, 'Stream connection closed');
+                    assert.strictEqual(params.error, null);
                 });
             });
 
-            it('should return an error if the password is not of type string and a callback has been provided', function (done) {
+            it('should return an error if the password is not correct and a callback has been provided', function (done) {
                 if (helper.redisProcess().spawnFailed()) this.skip();
 
                 client = redis.createClient.apply(null, args);
@@ -192,7 +202,7 @@ describe('client authentication', function () {
                 assert(async);
             });
 
-            it('should emit an error if the password is not of type string and no callback has been provided', function (done) {
+            it('should emit an error if the password is not correct and no callback has been provided', function (done) {
                 if (helper.redisProcess().spawnFailed()) this.skip();
 
                 client = redis.createClient.apply(null, args);
@@ -262,13 +272,13 @@ describe('client authentication', function () {
                 var args = config.configureClient(parser, ip, {
                     password: auth
                 });
-                client = redis.createClient.apply(redis.createClient, args);
+                client = redis.createClient.apply(null, args);
                 client.set('foo', 'bar');
                 client.subscribe('somechannel', 'another channel', function (err, res) {
                     client.once('ready', function () {
                         assert.strictEqual(client.pub_sub_mode, 1);
                         client.get('foo', function (err, res) {
-                            assert.strictEqual(err.message, 'ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context');
+                            assert(/ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message));
                             done();
                         });
                     });
@@ -281,6 +291,48 @@ describe('client authentication', function () {
                     });
                 });
             });
+
+            it('individual commands work properly with batch', function (done) {
+                // quit => might return an error instead of "OK" in the exec callback... (if not connected)
+                // auth => might return an error instead of "OK" in the exec callback... (if no password is required / still loading on Redis <= 2.4)
+                // This could be fixed by checking the return value of the callback in the exec callback and
+                // returning the manipulated [error, result] from the callback.
+                // There should be a better solution though
+
+                var args = config.configureClient(parser, 'localhost', {
+                    noReadyCheck: true
+                });
+                client = redis.createClient.apply(null, args);
+                assert.strictEqual(client.selected_db, undefined);
+                var end = helper.callFuncAfter(done, 8);
+                client.on('monitor', function () {
+                    end(); // Should be called for each command after monitor
+                });
+                client.batch()
+                    .auth(auth)
+                    .SELECT(5, function (err, res) {
+                        assert.strictEqual(client.selected_db, 5);
+                        assert.strictEqual(res, 'OK');
+                        assert.notDeepEqual(client.serverInfo.db5, { avg_ttl: 0, expires: 0, keys: 1 });
+                    })
+                    .monitor()
+                    .set('foo', 'bar', helper.isString('OK'))
+                    .INFO('stats', function (err, res) {
+                        assert.strictEqual(res.indexOf('# Stats\r\n'), 0);
+                        assert.strictEqual(client.serverInfo.sync_full, '0');
+                    })
+                    .get('foo', helper.isString('bar'))
+                    .subscribe(['foo', 'bar'])
+                    .unsubscribe('foo')
+                    .SUBSCRIBE('/foo', helper.isString('/foo'))
+                    .psubscribe('*')
+                    .quit(helper.isString('OK')) // this might be interesting
+                    .exec(function (err, res) {
+                        res[4] = res[4].substr(0, 9);
+                        assert.deepEqual(res, ['OK', 'OK', 'OK', 'OK', '# Stats\r\n', 'bar', 'bar', 'foo', '/foo', '*', 'OK']);
+                        end();
+                    });
+            });
         });
     });
 

package.json

@@ -12,8 +12,6 @@ describe("The 'batch' method", function () {
         describe('using ' + parser + ' and ' + ip, function () {
 
             describe('when not connected', function () {
-                // TODO: This is somewhat broken and should be fixed in v.3
-                // The commands should return an error instead of returning an empty result
                 var client;
 
                 beforeEach(function (done) {
@@ -24,7 +22,7 @@ describe("The 'batch' method", function () {
                     client.on('end', done);
                 });
 
-                it('returns an empty array', function (done) {
+                it('returns an empty array for missing commands', function (done) {
                     var batch = client.batch();
                     batch.exec(function (err, res) {
                         assert.strictEqual(err, null);
@@ -33,7 +31,17 @@ describe("The 'batch' method", function () {
                     });
                 });
 
-                it('returns an empty array if promisified', function () {
+                it('returns an error for batch with commands', function (done) {
+                    var batch = client.batch();
+                    batch.set('foo', 'bar');
+                    batch.exec(function (err, res) {
+                        assert.strictEqual(err, null);
+                        assert.strictEqual(res[0].code, 'NR_CLOSED');
+                        done();
+                    });
+                });
+
+                it('returns an empty array for missing commands if promisified', function () {
                     return client.batch().execAsync().then(function (res) {
                         assert.strictEqual(res.length, 0);
                     });

test/auth.spec.js

@@ -30,25 +30,89 @@ describe("The 'client' method", function () {
                 });
 
                 it("lists connected clients when invoked with multi's chaining syntax", function (done) {
-                    client.multi().client('list').exec(function (err, results) {
-                        assert(pattern.test(results[0]), "expected string '" + results + "' to match " + pattern.toString());
-                        return done();
-                    });
+                    client.multi().client('list', helper.isType.string()).exec(helper.match(pattern, done));
                 });
 
                 it('lists connected clients when invoked with array syntax on client', function (done) {
-                    client.multi().client(['list']).exec(function (err, results) {
-                        assert(pattern.test(results[0]), "expected string '" + results + "' to match " + pattern.toString());
-                        return done();
-                    });
+                    client.multi().client(['list']).exec(helper.match(pattern, done));
                 });
 
                 it("lists connected clients when invoked with multi's array syntax", function (done) {
                     client.multi([
                         ['client', 'list']
-                    ]).exec(function (err, results) {
-                        assert(pattern.test(results[0]), "expected string '" + results + "' to match " + pattern.toString());
-                        return done();
+                    ]).exec(helper.match(pattern, done));
+                });
+            });
+
+            describe('reply', function () {
+                describe('as normal command', function () {
+                    it('on', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        assert.strictEqual(client.reply, 'ON');
+                        client.client('reply', 'on', helper.isString('OK'));
+                        assert.strictEqual(client.reply, 'ON');
+                        client.set('foo', 'bar', done);
+                    });
+
+                    it('off', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        assert.strictEqual(client.reply, 'ON');
+                        client.client(new Buffer('REPLY'), 'OFF', helper.isUndefined());
+                        assert.strictEqual(client.reply, 'OFF');
+                        client.set('foo', 'bar', helper.isUndefined(done));
+                    });
+
+                    it('skip', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        assert.strictEqual(client.reply, 'ON');
+                        client.client('REPLY', new Buffer('SKIP'), helper.isUndefined());
+                        assert.strictEqual(client.reply, 'SKIP_ONE_MORE');
+                        client.set('foo', 'bar', helper.isUndefined());
+                        client.get('foo', helper.isString('bar', done));
+                    });
+                });
+
+                describe('in a batch context', function () {
+                    it('on', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        var batch = client.batch();
+                        assert.strictEqual(client.reply, 'ON');
+                        batch.client('reply', 'on', helper.isString('OK'));
+                        assert.strictEqual(client.reply, 'ON');
+                        batch.set('foo', 'bar');
+                        batch.exec(function (err, res) {
+                            assert.deepEqual(res, ['OK', 'OK']);
+                            done(err);
+                        });
+                    });
+
+                    it('off', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        var batch = client.batch();
+                        assert.strictEqual(client.reply, 'ON');
+                        batch.set('hello', 'world');
+                        batch.client(new Buffer('REPLY'), new Buffer('OFF'), helper.isUndefined());
+                        batch.set('foo', 'bar', helper.isUndefined());
+                        batch.exec(function (err, res) {
+                            assert.strictEqual(client.reply, 'OFF');
+                            assert.deepEqual(res, ['OK', undefined, undefined]);
+                            done(err);
+                        });
+                    });
+
+                    it('skip', function (done) {
+                        helper.serverVersionAtLeast.call(this, client, [3, 2, 0]);
+                        assert.strictEqual(client.reply, 'ON');
+                        client.batch()
+                            .set('hello', 'world')
+                            .client('REPLY', 'SKIP', helper.isUndefined())
+                            .set('foo', 'bar', helper.isUndefined())
+                            .get('foo')
+                            .exec(function (err, res) {
+                                assert.strictEqual(client.reply, 'ON');
+                                assert.deepEqual(res, ['OK', undefined, undefined, 'bar']);
+                                done(err);
+                            });
                     });
                 });
             });
@@ -57,7 +121,7 @@ describe("The 'client' method", function () {
                 var client2;
 
                 beforeEach(function (done) {
-                    client2 = redis.createClient.apply(redis.createClient, args);
+                    client2 = redis.createClient.apply(null, args);
                     client2.once('ready', function () {
                         done();
                     });
@@ -72,9 +136,9 @@ describe("The 'client' method", function () {
                     // per chunk. So the execution order is only garanteed on each client
                     var end = helper.callFuncAfter(done, 2);
 
-                    client.client('setname', 'RUTH', helper.isString('OK'));
-                    client2.client('setname', 'RENEE', helper.isString('OK'));
-                    client2.client('setname', 'MARTIN', helper.isString('OK'));
+                    client.client('setname', 'RUTH');
+                    client2.client('setname', ['RENEE'], helper.isString('OK'));
+                    client2.client(['setname', 'MARTIN'], helper.isString('OK'));
                     client2.client('getname', function (err, res) {
                         assert.equal(res, 'MARTIN');
                         end();

test/batch.spec.js

@@ -31,7 +31,7 @@ describe("The 'dbsize' method", function () {
 
                 it('reports an error', function (done) {
                     client.dbsize([], function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });

test/commands/client.spec.js

@@ -31,7 +31,7 @@ describe("The 'flushdb' method", function () {
 
                 it('reports an error', function (done) {
                     client.flushdb(function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });

test/commands/dbsize.spec.js

@@ -31,14 +31,14 @@ describe("The 'get' method", function () {
 
                 it('reports an error', function (done) {
                     client.get(key, function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });
 
                 it('reports an error promisified', function () {
                     return client.getAsync(key).then(assert, function (err) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                     });
                 });
             });

test/commands/flushdb.spec.js

@@ -32,7 +32,7 @@ describe("The 'getset' method", function () {
 
                 it('reports an error', function (done) {
                     client.get(key, function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });

test/commands/get.spec.js

@@ -22,29 +22,31 @@ describe("The 'hgetall' method", function () {
                 });
 
                 it('handles simple keys and values', function (done) {
-                    client.hmset(['hosts', 'mjr', '1', 'another', '23', 'home', '1234'], helper.isString('OK'));
+                    client.hmset(['hosts', '__proto__', '1', 'another', '23', 'home', '1234'], helper.isString('OK'));
                     client.HGETALL(['hosts'], function (err, obj) {
-                        assert.strictEqual(3, Object.keys(obj).length);
-                        assert.strictEqual('1', obj.mjr.toString());
+                        if (!/^v0\.10/.test(process.version)) {
+                            assert.strictEqual(3, Object.keys(obj).length);
+                            assert.strictEqual('1', obj.__proto__.toString()); // eslint-disable-line no-proto
+                        }
                         assert.strictEqual('23', obj.another.toString());
                         assert.strictEqual('1234', obj.home.toString());
-                        return done(err);
+                        done(err);
                     });
                 });
 
                 it('handles fetching keys set using an object', function (done) {
-                    client.HMSET('msg_test', { message: 'hello' }, helper.isString('OK'));
+                    client.batch().HMSET('msg_test', { message: 'hello' }, undefined).exec();
                     client.hgetall('msg_test', function (err, obj) {
                         assert.strictEqual(1, Object.keys(obj).length);
                         assert.strictEqual(obj.message, 'hello');
-                        return done(err);
+                        done(err);
                     });
                 });
 
                 it('handles fetching a messing key', function (done) {
                     client.hgetall('missing', function (err, obj) {
                         assert.strictEqual(null, obj);
-                        return done(err);
+                        done(err);
                     });
                 });
             });

test/commands/getset.spec.js

@@ -39,7 +39,7 @@ describe("The 'hmset' method", function () {
             });
 
             it('handles object-style syntax and the key being a number', function (done) {
-                client.HMSET(231232, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value', 'otherTypes': 555}, helper.isString('OK'));
+                client.HMSET(231232, {'0123456789': 'abcdefghij', 'some manner of key': 'a type of value', 'otherTypes': 555}, undefined);
                 client.HGETALL(231232, function (err, obj) {
                     assert.equal(obj['0123456789'], 'abcdefghij');
                     assert.equal(obj['some manner of key'], 'a type of value');

test/commands/hgetall.spec.js

@@ -23,16 +23,16 @@ describe("The 'info' method", function () {
                 client.end(true);
             });
 
-            it('update server_info after a info command', function (done) {
+            it('update serverInfo after a info command', function (done) {
                 client.set('foo', 'bar');
                 client.info();
                 client.select(2, function () {
-                    assert.strictEqual(client.server_info.db2, undefined);
+                    assert.strictEqual(client.serverInfo.db2, undefined);
                 });
                 client.set('foo', 'bar');
                 client.info();
                 setTimeout(function () {
-                    assert.strictEqual(typeof client.server_info.db2, 'object');
+                    assert.strictEqual(typeof client.serverInfo.db2, 'object');
                     done();
                 }, 30);
             });

test/commands/hmset.spec.js

@@ -33,7 +33,7 @@ describe("The 'mset' method", function () {
 
                 it('reports an error', function (done) {
                     client.mset(key, value, key2, value2, function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });
@@ -96,7 +96,8 @@ describe("The 'mset' method", function () {
                         // this behavior is different from the 'set' behavior.
                         it('emits an error', function (done) {
                             client.on('error', function (err) {
-                                assert.equal(err.message, "ERR wrong number of arguments for 'mset' command");
+                                assert.strictEqual(err.message, "ERR wrong number of arguments for 'mset' command");
+                                assert.strictEqual(err.name, 'ReplyError');
                                 done();
                             });
 

test/commands/info.spec.js

@@ -23,7 +23,7 @@ describe("The 'select' method", function () {
 
                 it('returns an error if redis is not connected', function (done) {
                     var buffering = client.select(1, function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                     assert(typeof buffering === 'boolean');

test/commands/mset.spec.js

@@ -31,7 +31,7 @@ describe("The 'set' method", function () {
 
                 it('reports an error', function (done) {
                     client.set(key, value, function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                 });

test/commands/select.spec.js

@@ -20,7 +20,7 @@ describe('connection tests', function () {
     it('unofficially support for a private stream', function () {
         // While using a private stream, reconnection and other features are not going to work properly.
         // Besides that some functions also have to be monkey patched to be safe from errors in this case.
-        // Therefor this is not officially supported!
+        // Therefore this is not officially supported!
         var socket = new net.Socket();
         client = new redis.RedisClient({
             prefix: 'test'
@@ -53,7 +53,7 @@ describe('connection tests', function () {
                 }
             });
             client.set('foo', 'bar', function (err, res) {
-                assert.strictEqual(err.message, 'Redis connection gone from close event.');
+                assert.strictEqual(err.message, 'Stream connection ended and command aborted.');
                 called = -1;
             });
         });
@@ -62,7 +62,7 @@ describe('connection tests', function () {
             var called = false;
             client = redis.createClient(9999);
             client.set('foo', 'bar', function (err, res) {
-                assert.strictEqual(err.message, 'Redis connection gone from close event.');
+                assert.strictEqual(err.message, 'Stream connection ended and command aborted.');
                 called = true;
             });
             var bool = client.quit(function (err, res) {
@@ -93,6 +93,27 @@ describe('connection tests', function () {
             assert.strictEqual(bool, false);
         });
 
+        it('calling quit while connected without offline queue should end the connection when all commands have finished', function (done) {
+            var called = false;
+            client = redis.createClient({
+                enable_offline_queue: false
+            });
+            client.on('ready', function () {
+                client.set('foo', 'bar', function (err, res) {
+                    assert.strictEqual(res, 'OK');
+                    called = true;
+                });
+                var bool = client.quit(function (err, res) {
+                    assert.strictEqual(res, 'OK');
+                    assert.strictEqual(err, null);
+                    assert(called);
+                    done();
+                });
+                // TODO: In v.3 the quit command would be fired right away, so bool should be true
+                assert.strictEqual(bool, true);
+            });
+        });
+
         it('do not quit before connected or a connection issue is detected', function (done) {
             client = redis.createClient();
             client.set('foo', 'bar', helper.isString('OK'));
@@ -132,12 +153,14 @@ describe('connection tests', function () {
 
             describe('on lost connection', function () {
                 it('emit an error after max retry attempts and do not try to reconnect afterwards', function (done) {
-                    var max_attempts = 3;
+                    var maxAttempts = 3;
                     var options = {
                         parser: parser,
-                        max_attempts: max_attempts
+                        maxAttempts: maxAttempts
                     };
                     client = redis.createClient(options);
+                    assert.strictEqual(client.retryBackoff, 1.7);
+                    assert.strictEqual(client.retryDelay, 200);
                     assert.strictEqual(Object.keys(options).length, 2);
                     var calls = 0;
 
@@ -152,7 +175,7 @@ describe('connection tests', function () {
                     client.on('error', function (err) {
                         if (/Redis connection in broken state: maximum connection attempts.*?exceeded./.test(err.message)) {
                             process.nextTick(function () { // End is called after the error got emitted
-                                assert.strictEqual(calls, max_attempts - 1);
+                                assert.strictEqual(calls, maxAttempts - 1);
                                 assert.strictEqual(client.emitted_end, true);
                                 assert.strictEqual(client.connected, false);
                                 assert.strictEqual(client.ready, false);
@@ -236,74 +259,89 @@ describe('connection tests', function () {
 
                 it('emits error once if reconnecting after command has been executed but not yet returned without callback', function (done) {
                     client = redis.createClient.apply(null, args);
-                    client.on('error', function (err) {
-                        assert.strictEqual(err.code, 'UNCERTAIN_STATE');
-                        done();
-                    });
 
                     client.on('ready', function () {
-                        client.set('foo', 'bar');
+                        client.set('foo', 'bar', function (err) {
+                            assert.strictEqual(err.code, 'UNCERTAIN_STATE');
+                            done();
+                        });
                         // Abort connection before the value returned
                         client.stream.destroy();
                     });
                 });
 
-                it('retry_strategy used to reconnect with individual error', function (done) {
+                it('retryStrategy used to reconnect with individual error', function (done) {
                     var text = '';
                     var unhookIntercept = intercept(function (data) {
                         text += data;
                         return '';
                     });
-                    var end = helper.callFuncAfter(done, 2);
                     client = redis.createClient({
-                        retry_strategy: function (options) {
-                            if (options.total_retry_time > 150) {
+                        retryStrategy: function (options) {
+                            if (options.totalRetryTime > 150) {
                                 client.set('foo', 'bar', function (err, res) {
-                                    assert.strictEqual(err.message, 'Connection timeout');
-                                    end();
+                                    assert.strictEqual(err.message, 'Stream connection ended and command aborted.');
+                                    assert.strictEqual(err.origin.message, 'Connection timeout');
+                                    done();
                                 });
                                 // Pass a individual error message to the error handler
                                 return new Error('Connection timeout');
                             }
                             return Math.min(options.attempt * 25, 200);
                         },
-                        max_attempts: 5,
-                        retry_max_delay: 123,
+                        maxAttempts: 5,
+                        retryMaxDelay: 123,
                         port: 9999
                     });
-
-                    client.on('error', function (err) {
-                        unhookIntercept();
+                    process.nextTick(function () {
                         assert.strictEqual(
                             text,
                             'node_redis: WARNING: You activated the retry_strategy and max_attempts at the same time. This is not possible and max_attempts will be ignored.\n' +
                             'node_redis: WARNING: You activated the retry_strategy and retry_max_delay at the same time. This is not possible and retry_max_delay will be ignored.\n'
                         );
-                        assert.strictEqual(err.message, 'Connection timeout');
-                        assert(!err.code);
-                        end();
+                        unhookIntercept();
                     });
                 });
 
                 it('retry_strategy used to reconnect', function (done) {
-                    var end = helper.callFuncAfter(done, 2);
                     client = redis.createClient({
                         retry_strategy: function (options) {
                             if (options.total_retry_time > 150) {
                                 client.set('foo', 'bar', function (err, res) {
-                                    assert.strictEqual(err.code, 'ECONNREFUSED');
-                                    end();
+                                    assert.strictEqual(err.message, 'Stream connection ended and command aborted.');
+                                    assert.strictEqual(err.code, 'NR_CLOSED');
+                                    assert.strictEqual(err.origin.code, 'ECONNREFUSED');
+                                    done();
                                 });
                                 return false;
                             }
                             return Math.min(options.attempt * 25, 200);
                         },
                         port: 9999
                     });
+                });
 
+                it('retryStrategy used to reconnect with defaults', function (done) {
+                    var unhookIntercept = intercept(function () {
+                        return '';
+                    });
+                    redis.debugMode = true;
+                    client = redis.createClient({
+                        retryStrategy: function (options) {
+                            client.set('foo', 'bar');
+                            assert(redis.debugMode);
+                            return null;
+                        }
+                    });
+                    setTimeout(function () {
+                        client.stream.destroy();
+                    }, 50);
                     client.on('error', function (err) {
-                        assert.strictEqual(err.code, 'ECONNREFUSED');
-                        end();
+                        assert.strictEqual(err.code, 'NR_CLOSED');
+                        assert.strictEqual(err.message, 'Stream connection ended and command aborted.');
+                        unhookIntercept();
+                        redis.debugMode = false;
+                        done();
                     });
                 });
             });
@@ -344,7 +382,7 @@ describe('connection tests', function () {
                     });
                 });
 
-                it('use the system socket timeout if the connect_timeout has not been provided', function () {
+                it('use the system socket timeout if the connect_timeout has not been provided', function (done) {
                     client = redis.createClient({
                         parser: parser,
                         host: '2001:db8::ff00:42:8329' // auto detect ip v6
@@ -353,6 +391,7 @@ describe('connection tests', function () {
                     assert.strictEqual(client.connection_options.family, 6);
                     process.nextTick(function () {
                         assert.strictEqual(client.stream.listeners('timeout').length, 0);
+                        done();
                     });
                 });
 

test/commands/set.spec.js

@@ -29,6 +29,14 @@ if (!process.env.REDIS_TESTS_STARTED) {
     });
 }
 
+function arrayHelper (results) {
+    if (results instanceof Array) {
+        assert.strictEqual(results.length, 1, 'The array length may only be one element');
+        return results[0];
+    }
+    return results;
+}
+
 module.exports = {
     redisProcess: function () {
         return rp;
@@ -52,27 +60,38 @@ module.exports = {
     },
     isNumber: function (expected, done) {
         return function (err, results) {
-            assert.strictEqual(null, err, 'expected ' + expected + ', got error: ' + err);
-            assert.strictEqual(expected, results, expected + ' !== ' + results);
+            assert.strictEqual(err, null, 'expected ' + expected + ', got error: ' + err);
+            results = arrayHelper(results);
+            assert.strictEqual(results, expected, expected + ' !== ' + results);
             assert.strictEqual(typeof results, 'number', 'expected a number, got ' + typeof results);
             if (done) done();
         };
     },
     isString: function (str, done) {
         str = '' + str; // Make sure it's a string
         return function (err, results) {
-            assert.strictEqual(null, err, "expected string '" + str + "', got error: " + err);
+            assert.strictEqual(err, null, "expected string '" + str + "', got error: " + err);
+            results = arrayHelper(results);
             if (Buffer.isBuffer(results)) { // If options are passed to return either strings or buffers...
                 results = results.toString();
             }
-            assert.strictEqual(str, results, str + ' does not match ' + results);
+            assert.strictEqual(results, str, str + ' does not match ' + results);
             if (done) done();
         };
     },
     isNull: function (done) {
         return function (err, results) {
-            assert.strictEqual(null, err, 'expected null, got error: ' + err);
-            assert.strictEqual(null, results, results + ' is not null');
+            assert.strictEqual(err, null, 'expected null, got error: ' + err);
+            results = arrayHelper(results);
+            assert.strictEqual(results, null, results + ' is not null');
+            if (done) done();
+        };
+    },
+    isUndefined: function (done) {
+        return function (err, results) {
+            assert.strictEqual(err, null, 'expected null, got error: ' + err);
+            results = arrayHelper(results);
+            assert.strictEqual(results, undefined, results + ' is not undefined');
             if (done) done();
         };
     },
@@ -91,27 +110,39 @@ module.exports = {
     isType: {
         number: function (done) {
             return function (err, results) {
-                assert.strictEqual(null, err, 'expected any number, got error: ' + err);
+                assert.strictEqual(err, null, 'expected any number, got error: ' + err);
                 assert.strictEqual(typeof results, 'number', results + ' is not a number');
                 if (done) done();
             };
         },
+        string: function (done) {
+            return function (err, results) {
+                assert.strictEqual(err, null, 'expected any string, got error: ' + err);
+                assert.strictEqual(typeof results, 'string', results + ' is not a string');
+                if (done) done();
+            };
+        },
         positiveNumber: function (done) {
             return function (err, results) {
-                assert.strictEqual(null, err, 'expected positive number, got error: ' + err);
-                assert.strictEqual(true, (results > 0), results + ' is not a positive number');
+                assert.strictEqual(err, null, 'expected positive number, got error: ' + err);
+                assert(results > 0, results + ' is not a positive number');
                 if (done) done();
             };
         }
     },
     match: function (pattern, done) {
         return function (err, results) {
-            assert.strictEqual(null, err, 'expected ' + pattern.toString() + ', got error: ' + err);
+            assert.strictEqual(err, null, 'expected ' + pattern.toString() + ', got error: ' + err);
+            results = arrayHelper(results);
             assert(pattern.test(results), "expected string '" + results + "' to match " + pattern.toString());
             if (done) done();
         };
     },
     serverVersionAtLeast: function (connection, desired_version) {
+        // Wait until a connection has established (otherwise a timeout is going to be triggered at some point)
+        if (Object.keys(connection.server_info).length === 0) {
+            throw new Error('Version check not possible as the client is not yet ready or did not expose the version');
+        }
         // Return true if the server version >= desired_version
         var version = connection.server_info.versions;
         for (var i = 0; i < 3; i++) {
@@ -132,10 +163,11 @@ module.exports = {
         }
         var parsers = ['javascript'];
         var protocols = ['IPv4'];
-        try {
-            require('hiredis');
-            parsers.push('hiredis');
-        } catch (e) {/* ignore eslint */}
+        // The js parser works the same as the hiredis parser, just activate this if you want to be on the safe side
+        // try {
+        //     require('hiredis');
+        //     parsers.push('hiredis');
+        // } catch (e) {/* ignore eslint */}
         if (process.platform !== 'win32') {
             protocols.push('IPv6', '/tmp/redis.sock');
         }

test/connection.spec.js

@@ -3,6 +3,7 @@
 var assert = require('assert');
 var config = require('./lib/config');
 var helper = require('./helper');
+var utils = require('../lib/utils');
 var redis = config.redis;
 var zlib = require('zlib');
 var client;
@@ -110,31 +111,78 @@ describe("The 'multi' method", function () {
                 it('reports an error', function (done) {
                     var multi = client.multi();
                     var notBuffering = multi.exec(function (err, res) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                         done();
                     });
                     assert.strictEqual(notBuffering, false);
                 });
 
                 it('reports an error if promisified', function () {
                     return client.multi().execAsync().catch(function (err) {
-                        assert(err.message.match(/The connection has already been closed/));
+                        assert(err.message.match(/The connection is already closed/));
                     });
                 });
             });
 
             describe('when connected', function () {
 
-                beforeEach(function (done) {
+                beforeEach(function () {
                     client = redis.createClient.apply(null, args);
-                    client.once('connect', done);
+                });
+
+                describe('monitor and transactions do not work together', function () {
+
+                    it('results in a execabort', function (done) {
+                        // Check that transactions in combination with monitor result in an error
+                        client.monitor(function (e) {
+                            client.on('error', function (err) {
+                                assert.strictEqual(err.code, 'EXECABORT');
+                                done();
+                            });
+                            var multi = client.multi();
+                            multi.set('hello', 'world');
+                            multi.exec();
+                        });
+                    });
+
+                    it('results in a execabort #2', function (done) {
+                        // Check that using monitor with a transactions results in an error
+                        client.multi().set('foo', 'bar').monitor().exec(function (err, res) {
+                            assert.strictEqual(err.code, 'EXECABORT');
+                            done();
+                        });
+                    });
+
+                    it('sanity check', function (done) {
+                        // Remove the listener and add it back again after the error
+                        var mochaListener = helper.removeMochaListener();
+                        process.on('uncaughtException', function (err) {
+                            helper.removeMochaListener();
+                            process.on('uncaughtException', mochaListener);
+                            done();
+                        });
+                        // Check if Redis still has the error
+                        client.monitor();
+                        client.send_command('multi');
+                        client.send_command('set', ['foo', 'bar']);
+                        client.send_command('get', ['foo']);
+                        client.send_command('exec', function (err, res) {
+                            // res[0] is going to be the monitor result of set
+                            // res[1] is going to be the result of the set command
+                            assert(utils.monitor_regex.test(res[0]));
+                            assert.strictEqual(res[1], 'OK');
+                            assert.strictEqual(res.length, 2);
+                            client.end(false);
+                        });
+                    });
                 });
 
                 it('executes a pipelined multi properly in combination with the offline queue', function (done) {
                     var multi1 = client.multi();
                     multi1.set('m1', '123');
                     multi1.get('m1');
                     multi1.exec(done);
+                    assert.strictEqual(client.offline_queue.length, 4);
                 });
 
                 it('executes a pipelined multi properly after a reconnect in combination with the offline queue', function (done) {
@@ -180,7 +228,8 @@ describe("The 'multi' method", function () {
 
                     client.multi([['set', 'foo', 'bar'], ['get', 'foo']]).exec(function (err, res) {
                         assert(/Redis connection in broken state/.test(err.message));
-                        assert.strictEqual(err.errors.length, 0);
+                        assert.strictEqual(err.errors.length, 2);
+                        assert.strictEqual(err.errors[0].args.length, 2);
                     });
                 });
 
@@ -255,12 +304,12 @@ describe("The 'multi' method", function () {
                     multi2.set('m2', '456');
                     multi1.set('m1', '123');
                     multi1.get('m1');
-                    multi2.get('m2');
+                    multi2.get('m1');
                     multi2.ping();
 
                     multi1.exec(end);
                     multi2.exec(function (err, res) {
-                        assert.strictEqual(res[1], '456');
+                        assert.strictEqual(res[1], '123');
                         end();
                     });
                 });
@@ -571,7 +620,7 @@ describe("The 'multi' method", function () {
                         test = true;
                     };
                     multi.set('baz', 'binary');
-                    multi.exec_atomic();
+                    multi.EXEC_ATOMIC();
                     assert(test);
                 });
 
@@ -612,16 +661,56 @@ describe("The 'multi' method", function () {
                 });
 
                 it('emits error once if reconnecting after multi has been executed but not yet returned without callback', function (done) {
+                    // NOTE: If uncork is called async by postponing it to the next tick, this behavior is going to change.
+                    // The command won't be processed anymore two errors are returned instead of one
                     client.on('error', function (err) {
                         assert.strictEqual(err.code, 'UNCERTAIN_STATE');
-                        done();
+                        client.get('foo', function (err, res) {
+                            assert.strictEqual(res, 'bar');
+                            done();
+                        });
                     });
 
+                    // The commands should still be fired, no matter that the socket is destroyed on the same tick
                     client.multi().set('foo', 'bar').get('foo').exec();
                     // Abort connection before the value returned
                     client.stream.destroy();
                 });
 
+                it('indivdual commands work properly with multi', function (done) {
+                    // Neither of the following work properly in a transactions:
+                    // (This is due to Redis not returning the reply as expected / resulting in undefined behavior)
+                    // (Likely there are more commands that do not work with a transaction)
+                    //
+                    // auth => can't be called after a multi command
+                    // monitor => results in faulty return values e.g. multi().monitor().set('foo', 'bar').get('foo')
+                    //            returns ['OK, 'OK', 'monitor reply'] instead of ['OK', 'OK', 'bar']
+                    // quit => ends the connection before the exec
+                    // client reply skip|off => results in weird return values. Not sure what exactly happens
+                    // subscribe => enters subscribe mode and this does not work in combination with exec (the same for psubscribe, unsubscribe...)
+                    //
+
+                    assert.strictEqual(client.selected_db, undefined);
+                    var multi = client.multi();
+                    multi.select(5, function (err, res) {
+                        assert.strictEqual(client.selected_db, 5);
+                        assert.strictEqual(res, 'OK');
+                        assert.notDeepEqual(client.server_info.db5, { avg_ttl: 0, expires: 0, keys: 1 });
+                    });
+                    // multi.client('reply', 'on', helper.isString('OK')); // Redis v.3.2
+                    multi.set('foo', 'bar', helper.isString('OK'));
+                    multi.info(function (err, res) {
+                        assert.strictEqual(res.indexOf('# Server\r\nredis_version:'), 0);
+                        assert.deepEqual(client.server_info.db5, { avg_ttl: 0, expires: 0, keys: 1 });
+                    });
+                    multi.get('foo', helper.isString('bar'));
+                    multi.exec(function (err, res) {
+                        res[2] = res[2].substr(0, 10);
+                        assert.deepEqual(res, ['OK', 'OK', '# Server\r\n', 'bar']);
+                        done();
+                    });
+                });
+
             });
         });
     });

test/helper.js

@@ -19,8 +19,8 @@ describe('publish/subscribe', function () {
             beforeEach(function (done) {
                 var end = helper.callFuncAfter(done, 2);
 
-                pub = redis.createClient.apply(redis.createClient, args);
-                sub = redis.createClient.apply(redis.createClient, args);
+                pub = redis.createClient.apply(null, args);
+                sub = redis.createClient.apply(null, args);
                 pub.once('connect', function () {
                     pub.flushdb(function () {
                         end();
@@ -79,6 +79,7 @@ describe('publish/subscribe', function () {
 
                 it('does not fire subscribe events after reconnecting', function (done) {
                     var i = 0;
+                    var end = helper.callFuncAfter(done, 2);
                     sub.on('subscribe', function (chnl, count) {
                         assert.strictEqual(typeof count, 'number');
                         assert.strictEqual(++i, count);
@@ -91,9 +92,10 @@ describe('publish/subscribe', function () {
                     sub.unsubscribe(function (err, res) { // Do not pass a channel here!
                         assert.strictEqual(sub.pub_sub_mode, 2);
                         assert.deepEqual(sub.subscription_set, {});
+                        end();
                     });
                     sub.set('foo', 'bar', helper.isString('OK'));
-                    sub.subscribe(channel2, done);
+                    sub.subscribe(channel2, end);
                 });
             });
 
@@ -181,74 +183,46 @@ describe('publish/subscribe', function () {
                     sub.subscribe('chan9');
                     sub.unsubscribe('chan9');
                     pub.publish('chan8', 'something');
-                    sub.subscribe('chan9', function () {
-                        return done();
-                    });
+                    sub.subscribe('chan9', done);
                 });
 
                 it('handles SUB_UNSUB_MSG_SUB 2', function (done) {
-                    sub.psubscribe('abc*');
+                    sub.psubscribe('abc*', helper.isString('abc*'));
                     sub.subscribe('xyz');
                     sub.unsubscribe('xyz');
                     pub.publish('abcd', 'something');
-                    sub.subscribe('xyz', function () {
-                        return done();
-                    });
+                    sub.subscribe('xyz', done);
                 });
 
                 it('emits end event if quit is called from within subscribe', function (done) {
-                    sub.on('end', function () {
-                        return done();
-                    });
+                    sub.on('end', done);
                     sub.on('subscribe', function (chnl, count) {
                         sub.quit();
                     });
                     sub.subscribe(channel);
                 });
 
-                it('handles SUBSCRIBE_CLOSE_RESUBSCRIBE', function (done) {
+                it('subscribe; close; resubscribe with prototype inherited property names', function (done) {
                     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.
-                    */
+                    var channels = ['__proto__', 'channel 2'];
+                    var msg = ['hi from channel __proto__', 'hi from channel 2'];
+
                     sub.on('message', function (channel, message) {
-                        if (channel === 'chan1') {
-                            assert.strictEqual(message, 'hi on channel 1');
-                            sub.stream.end();
-                        } else if (channel === 'chan2') {
-                            assert.strictEqual(message, 'hi on channel 2');
-                            sub.stream.end();
-                        } else {
-                            sub.quit();
-                            pub.quit();
-                            assert.fail('test failed');
-                        }
+                        var n = Math.max(count - 1, 0);
+                        assert.strictEqual(channel, channels[n]);
+                        assert.strictEqual(message, msg[n]);
+                        if (count === 2) return done();
+                        sub.stream.end();
                     });
 
-                    sub.subscribe('chan1', 'chan2');
+                    sub.subscribe(channels);
 
                     sub.on('ready', function (err, results) {
+                        pub.publish(channels[count], msg[count]);
                         count++;
-                        if (count === 1) {
-                            pub.publish('chan1', 'hi on channel 1');
-                            return;
-                        } else if (count === 2) {
-                            pub.publish('chan2', 'hi on channel 2');
-                        } else {
-                            sub.quit(function () {
-                                pub.quit(function () {
-                                    return done();
-                                });
-                            });
-                        }
                     });
 
-                    pub.publish('chan1', 'hi on channel 1');
+                    pub.publish(channels[count], msg[count]);
                 });
             });
 
@@ -258,6 +232,10 @@ describe('publish/subscribe', function () {
                     var end = helper.callFuncAfter(done, 2);
                     sub.select(3);
                     sub.set('foo', 'bar');
+                    sub.set('failure', helper.isError()); // Triggering a warning while subscribing should work
+                    sub.mget('foo', 'bar', 'baz', 'hello', 'world', function (err, res) {
+                        assert.deepEqual(res, ['bar', null, null, null, null]);
+                    });
                     sub.subscribe('somechannel', 'another channel', function (err, res) {
                         end();
                         sub.stream.destroy();
@@ -302,7 +280,7 @@ describe('publish/subscribe', function () {
 
                 it('should only resubscribe to channels not unsubscribed earlier on a reconnect', function (done) {
                     sub.subscribe('/foo', '/bar');
-                    sub.unsubscribe('/bar', function () {
+                    sub.batch().unsubscribe(['/bar'], function () {
                         pub.pubsub('channels', function (err, res) {
                             assert.deepEqual(res, ['/foo']);
                             sub.stream.destroy();
@@ -313,7 +291,7 @@ describe('publish/subscribe', function () {
                                 });
                             });
                         });
-                    });
+                    }).exec();
                 });
 
                 it('unsubscribes, subscribes, unsubscribes... single and multiple entries mixed. Withouth callbacks', function (done) {
@@ -512,7 +490,7 @@ describe('publish/subscribe', function () {
                         return_buffers: true
                     });
                     sub2.on('ready', function () {
-                        sub2.psubscribe('*');
+                        sub2.batch().psubscribe('*', helper.isString('*')).exec();
                         sub2.subscribe('/foo');
                         sub2.on('pmessage', function (pattern, channel, message) {
                             assert.strictEqual(pattern.inspect(), new Buffer('*').inspect());
@@ -523,9 +501,59 @@ describe('publish/subscribe', function () {
                         pub.pubsub('numsub', '/foo', function (err, res) {
                             assert.deepEqual(res, ['/foo', 2]);
                         });
+                        // sub2 is counted twice as it subscribed with psubscribe and subscribe
                         pub.publish('/foo', 'hello world', helper.isNumber(3));
                     });
                 });
+
+                it('allows to listen to pmessageBuffer and pmessage', function (done) {
+                    var batch = sub.batch();
+                    var end = helper.callFuncAfter(done, 6);
+                    assert.strictEqual(sub.message_buffers, false);
+                    batch.psubscribe('*');
+                    batch.subscribe('/foo');
+                    batch.unsubscribe('/foo');
+                    batch.unsubscribe(helper.isNull());
+                    batch.subscribe(['/foo'], helper.isString('/foo'));
+                    batch.exec();
+                    assert.strictEqual(sub.shouldBuffer, false);
+                    sub.on('pmessageBuffer', function (pattern, channel, message) {
+                        assert.strictEqual(pattern.inspect(), new Buffer('*').inspect());
+                        assert.strictEqual(channel.inspect(), new Buffer('/foo').inspect());
+                        sub.quit(end);
+                    });
+                    // Either message_buffers or buffers has to be true, but not both at the same time
+                    assert.notStrictEqual(sub.message_buffers, sub.buffers);
+                    sub.on('pmessage', function (pattern, channel, message) {
+                        assert.strictEqual(pattern, '*');
+                        assert.strictEqual(channel, '/foo');
+                        assert.strictEqual(message, 'hello world');
+                        end();
+                    });
+                    sub.on('message', function (channel, message) {
+                        assert.strictEqual(channel, '/foo');
+                        assert.strictEqual(message, 'hello world');
+                        end();
+                    });
+                    setTimeout(function () {
+                        pub.pubsub('numsub', '/foo', function (err, res) {
+                            // There's one subscriber to this channel
+                            assert.deepEqual(res, ['/foo', 1]);
+                            end();
+                        });
+                        pub.pubsub('channels', function (err, res) {
+                            // There's exactly one channel that is listened too
+                            assert.deepEqual(res, ['/foo']);
+                            end();
+                        });
+                        pub.pubsub('numpat', function (err, res) {
+                            // One pattern is active
+                            assert.strictEqual(res, 1);
+                            end();
+                        });
+                        pub.publish('/foo', 'hello world', helper.isNumber(2));
+                    }, 50);
+                });
             });
 
             describe('punsubscribe', function () {
@@ -534,10 +562,7 @@ describe('publish/subscribe', function () {
                 });
 
                 it('executes callback when punsubscribe is called and there are no subscriptions', function (done) {
-                    pub.punsubscribe(function (err, results) {
-                        assert.strictEqual(null, results);
-                        done(err);
-                    });
+                    pub.batch().punsubscribe(helper.isNull()).exec(done);
                 });
             });
 
@@ -551,7 +576,7 @@ describe('publish/subscribe', function () {
                     });
                     // Get is forbidden
                     sub.get('foo', function (err, res) {
-                        assert.strictEqual(err.message, 'ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context');
+                        assert(/^ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message));
                         assert.strictEqual(err.command, 'GET');
                     });
                     // Quit is allowed
@@ -561,7 +586,7 @@ describe('publish/subscribe', function () {
                 it('emit error if only pub sub commands are allowed without callback', function (done) {
                     sub.subscribe('channel');
                     sub.on('error', function (err) {
-                        assert.strictEqual(err.message, 'ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context');
+                        assert(/^ERR only \(P\)SUBSCRIBE \/ \(P\)UNSUBSCRIBE/.test(err.message));
                         assert.strictEqual(err.command, 'GET');
                         done();
                     });
@@ -614,6 +639,24 @@ describe('publish/subscribe', function () {
                 });
             });
 
+            it('arguments variants', function (done) {
+                sub.batch()
+                    .info(['stats'])
+                    .info()
+                    .client('KILL', ['type', 'pubsub'])
+                    .client('KILL', ['type', 'pubsub'], function () {})
+                    .unsubscribe()
+                    .psubscribe(['pattern:*'])
+                    .punsubscribe('unkown*')
+                    .punsubscribe(['pattern:*'])
+                    .exec(function (err, res) {
+                        sub.client('kill', ['type', 'pubsub']);
+                        sub.psubscribe('*');
+                        sub.punsubscribe('pa*');
+                        sub.punsubscribe(['a', '*'], done);
+                    });
+            });
+
             afterEach(function () {
                 // Explicitly ignore still running commands
                 pub.end(false);

test/multi.spec.js

@@ -252,7 +252,7 @@ describe('return_buffers', function () {
                     var subConnected;
 
                     pub = redis.createClient.apply(redis.createClient, basicArgs);
-                    sub = redis.createClient.apply(redis.createClient, args);
+                    sub = redis.createClient.apply(null, args);
                     pub.once('connect', function () {
                         pub.flushdb(function () {
                             pubConnected = true;

test/node_redis.spec.js

@@ -60,6 +60,7 @@ describe('TLS connection tests', function () {
                 tls: tls_options
             });
             var time = 0;
+            assert.strictEqual(client.address, '127.0.0.1:' + tls_port);
 
             client.once('ready', function () {
                 helper.killConnection(client);
@@ -87,18 +88,20 @@ describe('TLS connection tests', function () {
 
     describe('when not connected', function () {
 
-        it('connect with host and port provided in the options object', function (done) {
+        it('connect with host and port provided in the tls object', function (done) {
             if (skip) this.skip();
+            var tls = utils.clone(tls_options);
+            tls.port = tls_port;
+            tls.host = 'localhost';
             client = redis.createClient({
-                host: 'localhost',
                 connect_timeout: 1000,
-                port: tls_port,
-                tls: tls_options
+                tls: tls
             });
 
             // verify connection is using TCP, not UNIX socket
             assert.strictEqual(client.connection_options.host, 'localhost');
             assert.strictEqual(client.connection_options.port, tls_port);
+            assert.strictEqual(client.address, 'localhost:' + tls_port);
             assert(client.stream.encrypted);
 
             client.set('foo', 'bar');
@@ -115,6 +118,7 @@ describe('TLS connection tests', function () {
                 port: tls_port,
                 tls: faulty_cert
             });
+            assert.strictEqual(client.address, 'localhost:' + tls_port);
             client.on('error', function (err) {
                 assert(/DEPTH_ZERO_SELF_SIGNED_CERT/.test(err.code || err.message), err);
                 client.end(true);

test/pubsub.spec.js

@@ -11,7 +11,7 @@ describe('utils.js', function () {
         it('ignore the object prototype and clone a nested array / object', function () {
             var obj = {
                 a: [null, 'foo', ['bar'], {
-                    "I'm special": true
+                    "i'm special": true
                 }],
                 number: 5,
                 fn: function noop () {}
@@ -22,13 +22,28 @@ describe('utils.js', function () {
             assert(typeof clone.fn === 'function');
         });
 
-        it('replace faulty values with an empty object as return value', function () {
+        it('replace falsy values with an empty object as return value', function () {
             var a = utils.clone();
             var b = utils.clone(null);
             assert.strictEqual(Object.keys(a).length, 0);
             assert.strictEqual(Object.keys(b).length, 0);
         });
 
+        it('transform camelCase options to snack_case and add the camel_case option', function () {
+            var a = utils.clone({
+                optionOneTwo: true,
+                retryStrategy: false,
+                nested: {
+                    onlyContainCamelCaseOnce: true
+                }
+            });
+            assert.strictEqual(Object.keys(a).length, 4);
+            assert.strictEqual(a.option_one_two, true);
+            assert.strictEqual(a.retry_strategy, false);
+            assert.strictEqual(a.camel_case, true);
+            assert.strictEqual(Object.keys(a.nested).length, 1);
+        });
+
         it('throws on circular data', function () {
             try {
                 var a = {};
@@ -92,7 +107,7 @@ describe('utils.js', function () {
             emitted = false;
         });
 
-        it('no elements in either queue. Reply in the next tick', function (done) {
+        it('no elements in either queue. Reply in the next tick with callback', function (done) {
             var called = false;
             utils.reply_in_order(clientMock, function () {
                 called = true;
@@ -101,7 +116,7 @@ describe('utils.js', function () {
             assert(!called);
         });
 
-        it('no elements in either queue. Reply in the next tick', function (done) {
+        it('no elements in either queue. Reply in the next tick without callback', function (done) {
             assert(!emitted);
             utils.reply_in_order(clientMock, null, new Error('tada'));
             assert(!emitted);
@@ -138,16 +153,21 @@ describe('utils.js', function () {
             }
         });
 
-        it('elements in the offline queue. Reply after the offline queue is empty and respect the command_obj', function (done) {
-            clientMock.command_queue.push(create_command_obj(), {});
-            utils.reply_in_order(clientMock, function () {
+        it('elements in the offline queue and the command_queue. Reply all other commands got handled respect the command_obj', function (done) {
+            clientMock.command_queue.push(create_command_obj(), create_command_obj());
+            clientMock.offline_queue.push(create_command_obj(), {});
+            utils.reply_in_order(clientMock, function (err, res) {
                 assert.strictEqual(clientMock.command_queue.length, 0);
+                assert.strictEqual(clientMock.offline_queue.length, 0);
                 assert(!emitted);
-                assert.strictEqual(res_count, 1);
+                assert.strictEqual(res_count, 3);
                 done();
             }, null, null);
+            while (clientMock.offline_queue.length) {
+                clientMock.command_queue.push(clientMock.offline_queue.shift());
+            }
             while (clientMock.command_queue.length) {
-                clientMock.command_queue.shift().callback(null, 'bar');
+                clientMock.command_queue.shift().callback(null, 'hello world');
             }
         });
     });