Add a lot more tests to indicate that the everything is consistent

Add a test for #390

More special cases

test/commands/hmset.spec.js

@@ -83,6 +83,24 @@ describe("The 'hmset' method", function () {
                 });
             });
 
+            it('allows a key plus array without callback', function (done) {
+                client.HMSET(hash, [99, 'banana', 'test', 25]);
+                client.HGETALL(hash, function (err, obj) {
+                    assert.equal(obj['99'], 'banana');
+                    assert.equal(obj.test, '25');
+                    return done(err);
+                });
+            });
+
+            it('allows a key plus array and a callback', function (done) {
+                client.HMSET(hash, [99, 'banana', 'test', 25], helper.isString('OK'));
+                client.HGETALL(hash, function (err, obj) {
+                    assert.equal(obj['99'], 'banana');
+                    assert.equal(obj.test, '25');
+                    return done(err);
+                });
+            });
+
             it('handles object-style syntax without callback', function (done) {
                 client.HMSET(hash, {"0123456789": "abcdefghij", "some manner of key": "a type of value"});
                 client.HGETALL(hash, function (err, obj) {

test/commands/keys.spec.js

@@ -23,7 +23,7 @@ describe("The 'keys' method", function () {
 
             it('returns matching keys', function (done) {
                 client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], helper.isString("OK"));
-                client.KEYS(["test keys*"], function (err, results) {
+                client.KEYS("test keys*", function (err, results) {
                     assert.strictEqual(2, results.length);
                     assert.ok(~results.indexOf("test keys 1"));
                     assert.ok(~results.indexOf("test keys 2"));

test/commands/mget.spec.js

@@ -42,7 +42,7 @@ describe("The 'mget' method", function () {
             });
 
             it('handles fetching multiple keys, when some keys do not exist', function (done) {
-                client.MGET(["mget keys 1", "some random shit", "mget keys 2", "mget keys 3"], function (err, results) {
+                client.MGET("mget keys 1", ["some random shit", "mget keys 2", "mget keys 3"], function (err, results) {
                     assert.strictEqual(4, results.length);
                     assert.strictEqual("mget val 1", results[0].toString());
                     assert.strictEqual(null, results[1]);

test/commands/mset.spec.js

@@ -88,6 +88,12 @@ describe("The 'mset' method", function () {
                             client.get(key, helper.isString(value2));
                             client.get(key2, helper.isString(value, done));
                         });
+
+                        it("sets the value correctly with array syntax", function (done) {
+                            client.mset([key, value2, key2, value]);
+                            client.get([key, helper.isString(value2)]);
+                            client.get(key2, helper.isString(value, done));
+                        });
                     });
 
                     describe("with undefined 'key' and missing 'value'  parameter", function () {

test/commands/multi.spec.js

@@ -123,7 +123,7 @@ describe("The 'multi' method", function () {
 
                 it('handles multiple operations being applied to a set', function (done) {
                     client.sadd("some set", "mem 1");
-                    client.sadd("some set", "mem 2");
+                    client.sadd(["some set", "mem 2"]);
                     client.sadd("some set", "mem 3");
                     client.sadd("some set", "mem 4");
 
@@ -136,7 +136,7 @@ describe("The 'multi' method", function () {
 
                     // test nested multi-bulk replies with empty mb elements.
                     client.multi([
-                        ["smembers", "some set"],
+                        ["smembers", ["some set"]],
                         ["del", "some set"],
                         ["smembers", "some set"]
                     ])
@@ -148,6 +148,40 @@ describe("The 'multi' method", function () {
                     });
                 });
 
+                it('allows multiple operations to be performed using constructor with all kinds of syntax', function (done) {
+                    var now = Date.now();
+                    client.multi([
+                        ["mset", [578, "multibar"], helper.isString('OK')],
+                        [["mset", "multifoo2", "multibar2", "multifoo3", "multibar3"], helper.isString('OK')],
+                        ["hmset", ["multihmset", "multibar", "multibaz"]],
+                        [["hmset", "multihmset2", "multibar2", "multifoo3", "multibar3", "test", helper.isString('OK')]],
+                        ["hmset", ["multihmset", "multibar", "multifoo", helper.isString('OK')]],
+                        ["hmset", [5768, "multibarx", "multifoox"], helper.isString('OK')],
+                        ['hmset', now, {123456789: "abcdefghij", "some manner of key": "a type of value", "otherTypes": 555}],
+                        ['hmset', 'key2', {"0123456789": "abcdefghij", "some manner of key": "a type of value", "otherTypes": 999}, helper.isString('OK')],
+                        ["hmset", "multihmset", ["multibar", "multibaz"]],
+                        ["hmset", "multihmset", ["multibar", "multibaz"], helper.isString('OK')],
+                    ])
+                    .hmget(now, 123456789, 'otherTypes')
+                    .hmget('key2', ['some manner of key', 'otherTypes'])
+                    .hmget(['multihmset2', 'some manner of key', 'multibar3'])
+                    .mget('multifoo2', ['multifoo3', 'multifoo'], function(err, res) {
+                        assert(res[0], 'multifoo3');
+                        assert(res[1], 'multifoo');
+                    })
+                    .exec(function (err, replies) {
+                        assert.strictEqual(null, err);
+                        assert.equal(replies[10][1], '555');
+                        assert.equal(replies[11][0], 'a type of value');
+                        assert.strictEqual(replies[12][0], null);
+                        assert.equal(replies[12][1], 'test');
+                        assert.equal(replies[13][0], 'multibar2');
+                        assert.equal(replies[13].length, 3);
+                        assert.equal(replies.length, 14);
+                        return done();
+                    });
+                });
+
                 it('allows multiple operations to be performed using a chaining API', function (done) {
                     client.multi()
                         .mset('some', '10', 'keys', '20')
@@ -168,8 +202,8 @@ describe("The 'multi' method", function () {
                 it('allows multiple commands to work the same as normal to be performed using a chaining API', function (done) {
                     client.multi()
                         .mset(['some', '10', 'keys', '20'])
-                        .incr('some')
+                        .incr(['some', helper.isNumber(11)])
-                        .incr('keys')
+                        .incr(['keys'], helper.isNumber(21))
                         .mget('some', 'keys')
                         .exec(function (err, replies) {
                             assert.strictEqual(null, err);

test/commands/rpush.spec.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var config = require("../lib/config");
+var helper = require("../helper");
+var redis = config.redis;
+var assert = require('assert');
+
+describe("The 'rpush' command", function () {
+
+    helper.allTests(function(parser, ip, args) {
+
+        describe("using " + parser + " and " + ip, function () {
+            var client;
+
+            beforeEach(function (done) {
+                client = redis.createClient.apply(redis.createClient, args);
+                client.once("error", done);
+                client.once("connect", function () {
+                    client.flushdb(done);
+                });
+            });
+
+            it('inserts multiple values at a time into a list', function (done) {
+                client.rpush('test', ['list key', 'should be a list']);
+                client.lrange('test', 0, -1, function(err, res) {
+                    assert.equal(res[0], 'list key');
+                    assert.equal(res[1], 'should be a list');
+                    done(err);
+                });
+            });
+
+            afterEach(function () {
+                client.end();
+            });
+        });
+    });
+});

test/commands/sadd.spec.js

@@ -44,6 +44,17 @@ describe("The 'sadd' method", function () {
                 });
             });
 
+            it('allows multiple values to be added to the set with a different syntax', function (done) {
+                client.sadd(["set0", "member0", "member1", "member2"], helper.isNumber(3));
+                client.smembers("set0", function (err, res) {
+                    assert.strictEqual(res.length, 3);
+                    assert.ok(~res.indexOf("member0"));
+                    assert.ok(~res.indexOf("member1"));
+                    assert.ok(~res.indexOf("member2"));
+                    return done(err);
+                });
+            });
+
             afterEach(function () {
                 client.end();
             });

test/commands/sdiff.spec.js

@@ -22,11 +22,11 @@ describe("The 'sdiff' method", function () {
 
             it('returns set difference', function (done) {
                 client.sadd('foo', 'x', helper.isNumber(1));
-                client.sadd('foo', 'a', helper.isNumber(1));
+                client.sadd('foo', ['a'], helper.isNumber(1));
                 client.sadd('foo', 'b', helper.isNumber(1));
-                client.sadd('foo', 'c', helper.isNumber(1));
+                client.sadd(['foo', 'c'], helper.isNumber(1));
 
-                client.sadd('bar', 'c', helper.isNumber(1));
+                client.sadd(['bar', 'c', helper.isNumber(1)]);
 
                 client.sadd('baz', 'a', helper.isNumber(1));
                 client.sadd('baz', 'd', helper.isNumber(1));

test/commands/sort.spec.js

@@ -75,6 +75,13 @@ describe("The 'sort' method", function () {
                     });
                 });
 
+                it("handles sorting with a 'by' pattern and 2 'get' patterns with the array syntax", function (done) {
+                    client.sort(['x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*'], function (err, sorted) {
+                        assert.deepEqual(sorted, ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux']);
+                        return done(err);
+                    });
+                });
+
                 it("sorting with a 'by' pattern and 2 'get' patterns and stores results", function (done) {
                     client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', 'store', 'bacon', function (err) {
                         if (err) return done(err);

test/commands/srem.spec.js

@@ -41,8 +41,8 @@ describe("The 'srem' method", function () {
             });
 
             it('handles a value missing from the set of values being removed', function (done) {
-                client.sadd("set0", ["member0", "member1", "member2"], helper.isNumber(3));
+                client.sadd(["set0", "member0", "member1", "member2"], helper.isNumber(3));
-                client.SREM("set0", ["member3", "member4"], helper.isNumber(0));
+                client.SREM(["set0", "member3", "member4"], helper.isNumber(0));
                 client.smembers("set0", function (err, res) {
                     assert.strictEqual(res.length, 3);
                     assert.ok(~res.indexOf("member0"));

test/commands/type.spec.js

@@ -35,12 +35,12 @@ describe("The 'type' method", function () {
             });
 
             it('reports zset type', function (done) {
-                client.zadd(["zset key", "10.0", "should be a zset"], helper.isNumber(1));
+                client.zadd("zset key", ["10.0", "should be a zset"], helper.isNumber(1));
                 client.TYPE(["zset key"], helper.isString("zset", done));
             });
 
             it('reports hash type', function (done) {
-                client.hset(["hash key", "hashtest", "should be a hash"], helper.isNumber(1));
+                client.hset("hash key", "hashtest", "should be a hash", helper.isNumber(1));
                 client.TYPE(["hash key"], helper.isString("hash", done));
             });