1. module redis-mock
   1. function redis-mock._callCallback (callback, err, result)
   2. object redis-mock.hash
   3. object redis-mock.helpers
   4. object redis-mock.item
   5. object redis-mock.keys
   6. object redis-mock.list
   7. object redis-mock.pubsub
   8. object redis-mock.server
   9. object redis-mock.set
   10. object redis-mock.sortedset
   11. object redis-mock.storage
   12. object redis-mock.strings
2. module redis-mock.hash
   1. function redis-mock.hash.hdel (mockInstance, hash, key, callback)
   2. function redis-mock.hash.hexists (mockInstance, hash, key, callback)
   3. function redis-mock.hash.hget (mockInstance, hash, key, callback)
   4. function redis-mock.hash.hgetall (mockInstance, hash, callback)
   5. function redis-mock.hash.hincrby (mockInstance, hash, key, increment, callback)
   6. function redis-mock.hash.hincrbyfloat (mockInstance, hash, key, increment, callback)
   7. function redis-mock.hash.hkeys (mockInstance, hash, callback)
   8. function redis-mock.hash.hlen (mockInstance, hash, callback)
   9. function redis-mock.hash.hmget (mockInstance)
   10. function redis-mock.hash.hmset (mockInstance, hash)
   11. function redis-mock.hash.hset (mockInstance, hash, key, value, callback)
   12. function redis-mock.hash.hsetnx (mockInstance, hash, key, value, callback)
   13. function redis-mock.hash.hvals (mockInstance, hash, callback)
3. module redis-mock.helpers
   1. function redis-mock.helpers.initKey (mockInstance, key, fn)
   2. function redis-mock.helpers.mockCallback (err, reply)
   3. function redis-mock.helpers.parseCallback (args)
   4. function redis-mock.helpers.patternToRegex (pattern)
   5. function redis-mock.helpers.validKeyType (mockInstance, key, type, callback)
4. module redis-mock.item
   1. function redis-mock.item._hash ()
   2. function redis-mock.item._item (type, expire)
   3. function redis-mock.item._list ()
   4. function redis-mock.item._set ()
   5. function redis-mock.item._sortedset ()
   6. function redis-mock.item._string (value, expires)
   7. function redis-mock.item._stringify (value)
   8. function redis-mock.item.createHash ()
   9. function redis-mock.item.createList ()
   10. function redis-mock.item.createSet ()
   11. function redis-mock.item.createSortedSet ()
   12. function redis-mock.item.createString (elt, expire)
5. module redis-mock.keys
   1. function redis-mock.keys (mockInstance, pattern, callback)
   2. function redis-mock.keys.del (mockInstance, keys, callback)
   3. function redis-mock.keys.exists (mockInstance, key, callback)
   4. function redis-mock.keys.expire (mockInstance, key, seconds, callback)
   5. function redis-mock.keys.ttl (mockInstance, key, callback)
6. module redis-mock.list
   1. function redis-mock.list.blpop (mockInstance, keys, timeout, callback)
   2. function redis-mock.list.brpop (mockInstance, keys, timeout, callback)
   3. function redis-mock.list.lindex (mockInstance, key, index, callback)
   4. function redis-mock.list.llen (mockInstance, key, callback)
   5. function redis-mock.list.lpop (mockInstance, key, callback)
   6. function redis-mock.list.lpush ()
   7. function redis-mock.list.lpushx (mockInstance, key, value, callback)
   8. function redis-mock.list.lrange (mockInstance, key, startIndex, stopIndex, callback)
   9. function redis-mock.list.lset (mockInstance, key, index, value, callback)
   10. function redis-mock.list.rpop (mockInstance, key, callback)
   11. function redis-mock.list.rpush ()
   12. function redis-mock.list.rpushx (mockInstance, key, value, callback)
7. module redis-mock.pubsub
   1. function redis-mock.pubsub.psubscribe ()
   2. function redis-mock.pubsub.publish (mockInstance, channel, msg)
   3. function redis-mock.pubsub.punsubscribe ()
   4. function redis-mock.pubsub.subscribe ()
   5. function redis-mock.pubsub.unsubscribe ()
8. module redis-mock.server
   1. function redis-mock.server.auth (mockInstance, password, callback)
   2. function redis-mock.server.flushall (mockInstance, callback)
   3. function redis-mock.server.flushdb (mockInstance, callback)
9. module redis-mock.set
   1. function redis-mock.set.sadd (mockInstance, key, members, callback)
   2. function redis-mock.set.scard (mockInstance, key, callback)
   3. function redis-mock.set.sismember (mockInstance, key, member, callback)
   4. function redis-mock.set.smembers (mockInstance, key, callback)
   5. function redis-mock.set.srem (mockInstance, key, members, callback)
10. module redis-mock.sortedset
    1. function redis-mock.sortedset.zadd (mockInstance, key)
    2. function redis-mock.sortedset.zcard (mockInstance, key, callback)
    3. function redis-mock.sortedset.zcount (mockInstance, key, min, max, callback)
    4. function redis-mock.sortedset.zincrby (mockInstance, key, increment, member, callback)
    5. function redis-mock.sortedset.zrange (mockInstance, key, start, stop, withscores, callback)
    6. function redis-mock.sortedset.zrangebyscore ( mockInstance, key, min, max, withscores, limit, offset, count, callback)
    7. function redis-mock.sortedset.zrank (mockInstance, key, member, callback)
    8. function redis-mock.sortedset.zrem (mockInstance, key)
    9. function redis-mock.sortedset.zremrangebyrank (mockInstance, key, start, stop, callback)
    10. function redis-mock.sortedset.zremrangebyscore (mockInstance, key, min, max, callback)
    11. function redis-mock.sortedset.zrevrange (mockInstance, key, start, stop, withscores, callback)
    12. function redis-mock.sortedset.zrevrangebyscore ( mockInstance, key, max, min, withscores, limit, offset, count, callback)
    13. function redis-mock.sortedset.zrevrank (mockInstance, key, member, callback)
    14. function redis-mock.sortedset.zscore (mockInstance, key, member, callback)
11. module redis-mock.strings
    1. function redis-mock.strings.get (mockInstance, key, callback)
    2. function redis-mock.strings.getset (mockInstance, key, value, callback)
    3. function redis-mock.strings.incr (mockInstance, key, callback)
    4. function redis-mock.strings.incrby (mockInstance, key, value, callback)
    5. function redis-mock.strings.incrbyfloat (mockInstance, key, value, callback)
    6. function redis-mock.strings.mget (mockInstance)
    7. function redis-mock.strings.ping (mockInstance, callback)
    8. function redis-mock.strings.set (mockInstance, key, value, callback)
    9. function redis-mock.strings.setnx (mockInstance, key, value, callback)

module redis-mock

function redis-mock._callCallback (callback, err, result)

• description and source-code

  _callCallback = function (callback, err, result) {
    if (callback) {
      process.nextTick(function () {
        callback(err, result);
      });
    }
  }

• example usage

  ...
      if (mockInstance.storage[hash].type === "hash") {
        value = mockInstance.storage[hash].value[key];
      } else {
        err = new Error("ERR Operation against a key holding the wrong kind of value");
      }
    }
  
    mockInstance._callCallback(callback, err, value);
  }
  
  /**
   * Hexists
   */
  exports.hexists = function (mockInstance, hash, key, callback) {
  ...

module redis-mock.hash

function redis-mock.hash.hdel (mockInstance, hash, key, callback)

• description and source-code

  hdel = function (mockInstance, hash, key, callback) {
  
    var nb = 0;
  
    //TODO: Support multiple values as key
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type === "hash") {
        if (mockInstance.storage[hash].value[key]) {
          delete mockInstance.storage[hash].value[key];
          nb++;
        }
      } else {
        err = new Error("ERR Operation against a key holding the wrong kind of value");
      }
    }
  
    mockInstance._callCallback(callback, null, nb);
  }

• example usage

  ...
  
      });
  
      it("should delete a value", function (done) {
  
        var r = redismock.createClient();
  
        r.hdel(testHash, testKey, function (err, result) {
  
  result.should.equal(1);
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hexists (mockInstance, hash, key, callback)

• description and source-code

  hexists = function (mockInstance, hash, key, callback) {
  
    var b = 0;
    var err = null;
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type === "hash") {
        b = mockInstance.storage[hash].value[key] ? 1 : 0;
      } else {
        err = new Error("ERR Operation against a key holding the wrong kind of value");
      }
    }
  
    mockInstance._callCallback(callback, err, b);
  }

• example usage

  ...
  
    var testKeyNotExist = "myKeyNonExistant";
  
    it("should not say that non-existant values exist", function (done) {
  
  var r = redismock.createClient();
  
  r.hexists(testHash, testKey, function (err, result) {
    result.should.equal(0);
  
    r.end(true);
  
    done();
  
  });
  ...

function redis-mock.hash.hget (mockInstance, hash, key, callback)

• description and source-code

  hget = function (mockInstance, hash, key, callback) {
  
    var value = null;
    var err = null;
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type === "hash") {
        value = mockInstance.storage[hash].value[key];
      } else {
        err = new Error("ERR Operation against a key holding the wrong kind of value");
      }
    }
  
    mockInstance._callCallback(callback, err, value);
  }

• example usage

  ...
  
      });
  
      it("should get a value that has been set", function (done) {
  
        var r = redismock.createClient();
  
        r.hget(testHash, testKey, function (err, result) {
  
  result.should.equal(testValue);
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hgetall (mockInstance, hash, callback)

• description and source-code

  hgetall = function (mockInstance, hash, callback) {
  
    // TODO: Confirm if this should return null or empty obj when key does not exist
    var obj = {};
    var nb = 0;
  
    if (mockInstance.storage[hash] && mockInstance.storage[hash].type !== "hash") {
      return mockInstance._callCallback(callback,
        new Error("ERR Operation against a key holding the wrong kind of value"));
    }
    if (mockInstance.storage[hash]) {
      for (var k in mockInstance.storage[hash].value) {
        nb++;
        obj[k] = mockInstance.storage[hash].value[k];
      }
    }
  
    mockInstance._callCallback(callback, null, nb === 0 ? null : obj);
  }

• example usage

  ...
    });
  
    //HGETALL
    it("should be able to get all values for hash", function (done) {
  
      var r = redismock.createClient();
  
      r.hgetall(mHash2, function (err, result) {
  
  should.exist(result);
  
  result.should.have.property(mKey1, mValue1);
  result.should.have.property(mKey2, mValue2);
  result.should.have.property(mKey3, mValue3);
  result.should.have.property(mKey4, mValue4);
  ...

function redis-mock.hash.hincrby (mockInstance, hash, key, increment, callback)

• description and source-code

  hincrby = function (mockInstance, hash, key, increment, callback) {
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type !== "hash") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
    } else {
      mockInstance.storage[hash] = Item.createHash();
    }
  
    if (mockInstance.storage[hash].value[key] && !/^\d+$/.test(mockInstance.storage[hash].value[key])) {
      return mockInstance._callCallback(callback,
        new Error("ERR hash value is not an integer"));
    }
  
    mockInstance.storage[hash].value[key] = parseInt(mockInstance.storage[hash].value[key]) || 0;
  
    mockInstance.storage[hash].value[key] += increment;
  
    mockInstance.storage[hash].value[key] += ""; //Because HGET returns Strings
  
    mockInstance._callCallback(callback, null, parseInt(mockInstance.storage[hash].value[key])); //Because HINCRBY returns integers
  }

• example usage

  ...
    var testKey = "myKeyToIncr";
  
  
    it("should increment an attribute of the hash", function (done) {
  
      var r = redismock.createClient();
  
      r.hincrby(testHash, testKey, 2, function (err, result) {
  result.should.equal(2);
  
  r.hget(testHash, testKey, function (err, result) {
    result.should.equal("2");
    r.end(true);
    done();
  });
  ...

function redis-mock.hash.hincrbyfloat (mockInstance, hash, key, increment, callback)

• description and source-code

  hincrbyfloat = function (mockInstance, hash, key, increment, callback) {
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type !== "hash") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
    } else {
      mockInstance.storage[hash] = Item.createHash();
    }
  
    function isFloat(n) {
        return n === +n && n !== (n|0);
    }
  
    if (mockInstance.storage[hash].value[key] && !isFloat(parseFloat(mockInstance.storage[hash].value[key]))) {
      return mockInstance._callCallback(callback,
        new Error("ERR value is not a valid float"));
    }
  
    mockInstance.storage[hash].value[key] = parseFloat(mockInstance.storage[hash].value[key]) || 0;
    mockInstance.storage[hash].value[key] += parseFloat(increment);
    //convert to string
    mockInstance.storage[hash].value[key] = mockInstance.storage[hash].value[key].toString();
  
    mockInstance._callCallback(callback, null, mockInstance.storage[hash].value[key]);
  }

• example usage

  ...
    var num = 2.591;
    var x2 = num * 2;
  
    it("should increment an attribute of the hash", function (done) {
  
      var r = redismock.createClient();
  
      r.hincrbyfloat(testHash, testKey, num, function (err, result) {
  result.should.equal(num.toString());
  
  r.hget(testHash, testKey, function (err, result) {
    result.should.equal(num.toString());
    r.end(true);
    done();
  });
  ...

function redis-mock.hash.hkeys (mockInstance, hash, callback)

• description and source-code

  hkeys = function (mockInstance, hash, callback) {
  
    var list = [];
  
    if (mockInstance.storage[hash] && mockInstance.storage[hash].type !== "hash") {
      return mockInstance._callCallback(callback,
        new Error("ERR Operation against a key holding the wrong kind of value"));
    }
    if (mockInstance.storage[hash]) {
      for (var k in mockInstance.storage[hash].value) {
        list.push(k);
      }
    }
  
    mockInstance._callCallback(callback, null, list);
  }

• example usage

  ...
    })
  
    //HKEYS
    it("should be able to get all keys for hash", function (done) {
  
      var r = redismock.createClient();
  
      r.hkeys(mHash2, function (err, result) {
  
  result.indexOf(mKey1).should.not.equal(-1);
  result.indexOf(mKey2).should.not.equal(-1);
  result.indexOf(mKey3).should.not.equal(-1);
  result.indexOf(mKey4).should.not.equal(-1);
  
  r.end(true);
  ...

function redis-mock.hash.hlen (mockInstance, hash, callback)

• description and source-code

  hlen = function (mockInstance, hash, callback) {
  
    if (!mockInstance.storage[hash]) {
      return mockInstance._callCallback(callback, null, 0);
    }
    if (mockInstance.storage[hash].type !== "hash") {
      return mockInstance._callCallback(callback,
        new Error("ERR Operation against a key holding the wrong kind of value"));
    }
    var cnt = 0;
    for (var p in mockInstance.storage[hash].value) {
      if (mockInstance.storage[hash].value.hasOwnProperty(p)) {
        cnt++;
      }
    }
  
    mockInstance._callCallback(callback, null, cnt);
  }

• example usage

  ...
  
      });
  
      it("should return length 0 when key does not exist", function (done) {
  
        var r = redismock.createClient();
  
        r.hlen("newHash", function (err, result) {
  
  result.should.equal(0);
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hmget (mockInstance)

• description and source-code

  hmget = function (mockInstance) {
  
    // We require at least 3 arguments
    // 0: mockInstance
    // 1: hash name
    // 2: key/value object or first key name
    if (arguments.length <= 3) {
      return;
    }
  
    var keyValuesToGet = [];
  
    for (var i = 2; i < arguments.length; i++) {
  
      // Neither key nor value is a callback
      if ('function' !== typeof arguments[i] && 'function' !== typeof arguments[i]) {
  
        keyValuesToGet.push(arguments[i]);
  
      } else {
        break;
      }
    }
  
    var keyValues = [];
    var hash = arguments[1];
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type !== "hash") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      } else {
        for (var k in keyValuesToGet) {
          keyValues.push(mockInstance.storage[hash].value[keyValuesToGet[k]])
        }
      }
    } else {
      for (var k in keyValuesToGet) {
        keyValues.push(null)
      }
    }
  
    // Do we have a callback?
    if ('function' === typeof arguments[arguments.length - 1]) {
      mockInstance._callCallback(arguments[arguments.length - 1], null, keyValues);
    }
  }

• example usage

  ...
  
    // HMGET
    it("should be able to get multiple keys as multiple arguments", function (done) {
  
      var r = redismock.createClient();
  
      r.hmset(mHash, { mKey3: mValue3, mKey4: mValue4});
      r.hmget(mHash2, mKey1, mKey2, function (err, result) {
  
  result.should.be.an.Array().and.have.lengthOf(2);
  result.should.eql([mValue1, mValue2]);
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hmset (mockInstance, hash)

• description and source-code

  hmset = function (mockInstance, hash) {
  
    // We require at least 3 arguments
    // 0: mockInstance
    // 1: hash name
    // 2..N-2: key
    // 3..N-1: value
    // N: callback (optional)
  
    var len = arguments.length;
    if (len <= 3) {
      return;
    }
  
    var callback;
    if ('function' === typeof arguments[len - 1]) {
      callback = arguments[len-1];
    }
  
    // check to see if this hash exists
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type !== "hash" && callback) {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
    } else {
      mockInstance.storage[hash] = new Item.createHash();
    }
  
    for (var i = 2; i < len; i += 2) {
      if (len <= (i + 1)) {
        // should skip the callback here
        break;
      }
      var k = arguments[i];
      var v = arguments[i + 1];
      mockInstance.storage[hash].value[k] = v;
    }
  
    // Do we have a callback?
    if (callback) {
      mockInstance._callCallback(callback, null, "OK");
    }
  }

• example usage

  ...
    });
  
    // HMSET
    it("should be able to set multiple keys as multiple arguments", function (done) {
  
      var r = redismock.createClient();
  
      r.hmset(mHash, mKey1, mValue1, mKey2, mValue2, function (err, result) {
  
  result.should.equal("OK");
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hset (mockInstance, hash, key, value, callback)

• description and source-code

  hset = function (mockInstance, hash, key, value, callback) {
    var update = false;
  
    if (mockInstance.storage[hash]) {
      if (mockInstance.storage[hash].type !== "hash") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
      if (mockInstance.storage[hash].value[key]) {
        update = true;
      }
    } else {
      mockInstance.storage[hash] = Item.createHash();
    }
  
    mockInstance.storage[hash].value[key] = value;
  
    mockInstance._callCallback(callback, null, update ? 0 : 1);
  }

• example usage

  ...
  /**
   * Hsetnx
   */
  exports.hsetnx = function (mockInstance, hash, key, value, callback) {
    if (!mockInstance.storage[hash]
      || mockInstance.storage[hash].type !== "hash"
      || !mockInstance.storage[hash].value[key]) {
      exports.hset(mockInstance, hash, key, value, callback);
    } else {
      mockInstance._callCallback(callback, null, 0);
    }
  
  };
  
  /**
  ...

function redis-mock.hash.hsetnx (mockInstance, hash, key, value, callback)

• description and source-code

  hsetnx = function (mockInstance, hash, key, value, callback) {
    if (!mockInstance.storage[hash]
      || mockInstance.storage[hash].type !== "hash"
      || !mockInstance.storage[hash].value[key]) {
      exports.hset(mockInstance, hash, key, value, callback);
    } else {
      mockInstance._callCallback(callback, null, 0);
    }
  
  }

• example usage

  ...
      });
    });
  
    it("should set a value that does not exist", function (done) {
  
      var r = redismock.createClient();
  
      r.hsetnx(testHash, testKey2, testValue, function (err, result) {
  
  result.should.equal(1);
  
  r.end(true);
  
  done();
  ...

function redis-mock.hash.hvals (mockInstance, hash, callback)

• description and source-code

  hvals = function (mockInstance, hash, callback) {
  
    var list = [];
  
    if (mockInstance.storage[hash] && mockInstance.storage[hash].type !== "hash") {
      return mockInstance._callCallback(callback,
        new Error("ERR Operation against a key holding the wrong kind of value"));
    }
    if (mockInstance.storage[hash]) {
      for (var k in mockInstance.storage[hash].value) {
        list.push(mockInstance.storage[hash].value[k]);
      }
    }
  
    mockInstance._callCallback(callback, null, list);
  }

• example usage

  ...
    });
  
    //HVALS
    it("should be able to get all vals for hash", function (done) {
  
      var r = redismock.createClient();
  
      r.hvals(mHash2, function (err, result) {
  
  result.should.containEql(mValue1);
  result.should.containEql(mValue2);
  result.should.containEql(mValue3);
  result.should.containEql(mValue4);
  
  r.end(true);
  ...

module redis-mock.helpers

function redis-mock.helpers.initKey (mockInstance, key, fn)

• description and source-code

  initKey = function (mockInstance, key, fn) {
    mockInstance.storage[key] = mockInstance.storage[key] || fn();
  }

• example usage

  ...
  var mockCallback = helpers.mockCallback;
  
  var validKeyType = function(mockInstance, key, callback) {
  return helpers.validKeyType(mockInstance, key, 'list', callback)
  };
  
  var initKey = function(mockInstance, key) {
  return helpers.initKey(mockInstance, key, Item.createList);
  };
  
  /**
   * Llen
   */
  exports.llen = function (mockInstance, key, callback) {
  var length = mockInstance.storage[key] ? mockInstance.storage[key].value.length : 0;
  ...

function redis-mock.helpers.mockCallback (err, reply)

• description and source-code

  mockCallback = function (err, reply) {}

• example usage

  n/a

function redis-mock.helpers.parseCallback (args)

• description and source-code

  parseCallback = function (args) {
    var callback;
    var len = args.length;
    if ('function' === typeof args[len - 1]) {
      callback = args[len-1];
    }
    return callback;
  }

• example usage

  ...
  var push = function (fn, args) {
  var len = args.length;
  if (len < 2) {
    return
  }
  var mockInstance = args[0];
  var key = args[1];
  var callback = helpers.parseCallback(args);
  if (callback == undefined) {
    callback = mockCallback;
  }
  if (!validKeyType(mockInstance, key, callback)) {
    return
  }
  // init key
  ...

function redis-mock.helpers.patternToRegex (pattern)

• description and source-code

  patternToRegex = function (pattern) {
    var fixed = pattern.replace(patternChanger, function(matched) { return charMap[matched] });
    return new RegExp('^' + fixed + '$');
  }

• example usage

  ...
    var badStrings = ["h^llo", "h?llo", "h*llo", "h.llo", "h(llo", "h)llo&#
  x22;, "h{llo", "h}llo", "h\\llo", "h[llo", "h]llo"]
    testPattern(pattern, goodStrings, badStrings)
  })
  
  })
  
  function testPattern(pattern, passes, fails) {
  var regex = helpers.patternToRegex(pattern)
  withPattern(regex, passes, true)
  withPattern(regex, fails, false)
  }
  
  function withPattern(regex, strings, expected) {
  strings.forEach(function (x) {
    should.equal(regex.test(x), expected)
  ...

function redis-mock.helpers.validKeyType (mockInstance, key, type, callback)

• description and source-code

  validKeyType = function (mockInstance, key, type, callback) {
    if (mockInstance.storage[key] && mockInstance.storage[key].type !== type) {
      var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
      mockInstance._callCallback(callback, err);
      return false;
    }
    return true;
  }

• example usage

  ...
  var helpers = require("./helpers.js");
  var Item = require("./item.js");
  
  
  var mockCallback = helpers.mockCallback;
  
  var validKeyType = function(mockInstance, key, callback) {
    return helpers.validKeyType(mockInstance, key, 'list', callback)
  };
  
  var initKey = function(mockInstance, key) {
    return helpers.initKey(mockInstance, key, Item.createList);
  };
  
  /**
  ...

module redis-mock.item

function redis-mock.item._hash ()

• description and source-code

  _hash = function () {
    RedisItem.call(this, "hash");
    this.value = {};
  }

• example usage

  n/a

function redis-mock.item._item (type, expire)

• description and source-code

  _item = function (type, expire) {
    // We keep type so we don't have to use instanceof maybe this
    // can be changed to something more clever
    this.type = type || 0;
    this.expires = expire || -1;
  }

• example usage

  n/a

function redis-mock.item._list ()

• description and source-code

  _list = function () {
    RedisItem.call(this, "list");
    this.value = [];
  }

• example usage

  n/a

function redis-mock.item._set ()

• description and source-code

  _set = function () {
    RedisItem.call(this, "set");
    this.value = [];
  }

• example usage

  n/a

function redis-mock.item._sortedset ()

• description and source-code

  _sortedset = function () {
    RedisItem.call(this, "sortedset");
    this.value = {};
  }

• example usage

  n/a

function redis-mock.item._string (value, expires)

• description and source-code

  _string = function (value, expires) {
    RedisItem.call(this, "string", expires);
    this.value = String(value);
  }

• example usage

  n/a

function redis-mock.item._stringify (value)

• description and source-code

  _stringify = function (value) {
    return typeof(value) === "object" ?
      JSON.stringify(value) :
      value + '';
  }

• example usage

  ...
    }
    len = mockInstance.storage[key].value.length;
    if (len <= index || -len > index) {
      return mockInstance._callCallback(callback,
        new Error("ERR index out of range"));
    }
    if (index < 0) {
      mockInstance.storage[key].value[len + index] = Item._stringify(value);
    } else {
      mockInstance.storage[key].value[index] = Item._stringify(value);
    }
    mockInstance._callCallback(callback, null, res);
  };
  
  /**
  ...

function redis-mock.item.createHash ()

• description and source-code

  createHash = function () {
    return new RedisHash();
  }

• example usage

  ...
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
      if (mockInstance.storage[hash].value[key]) {
        update = true;
      }
    } else {
      mockInstance.storage[hash] = Item.createHash();
    }
  
    mockInstance.storage[hash].value[key] = value;
  
    mockInstance._callCallback(callback, null, update ? 0 : 1);
  };
  ...

function redis-mock.item.createList ()

• description and source-code

  createList = function () {
    return new RedisList();
  }

• example usage

  ...
  item.value.should.eql({});
    });
  });
  
  describe("Item.createList", function () {
    it('should create an empty list', function () {
  var elt = "foo";
  var item = RedisItem.createList();
  
  item.type.should.equal("list");
  item.expires.should.equal(-1);
  item.value.should.eql([]);
  should.exist(item.lpush);
  should.exist(item.lpop);
  should.exist(item.rpush);
  ...

function redis-mock.item.createSet ()

• description and source-code

  createSet = function () {
    return new RedisSet();
  }

• example usage

  ...
   */
  exports.sadd = function (mockInstance, key, members, callback) {
  if (mockInstance.storage[key] && mockInstance.storage[key].type !== 'set') {
    var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
    return mockInstance._callCallback(callback, err);
  }
  
  mockInstance.storage[key] = mockInstance.storage[key] || new Item.createSet();
  
  var set = mockInstance.storage[key].value;
  var addCount = 0;
  for (var i = 0; i < members.length; i++) {
    if (set.indexOf(Item._stringify(members[i])) < 0) {
      set.push(Item._stringify(members[i]));
      addCount++;
  ...

function redis-mock.item.createSortedSet ()

• description and source-code

  createSortedSet = function () {
    return new RedisSortedSet();
  }

• example usage

  ...
      item.expires.should.equal(1000);
      item.value.should.equal(elt);
    });
  });
  
  describe("Item.createSortedSet", function () {
    it('should create an empty sortedset', function () {
      var item = RedisItem.createSortedSet();
  
      item.type.should.equal("sortedset");
      item.expires.should.equal(-1);
      item.value.should.eql({});
    });
  });
  ...

function redis-mock.item.createString (elt, expire)

• description and source-code

  createString = function (elt, expire) {
    return new RedisString(elt, expire);
  }

• example usage

  ...
  var Item = require("./item.js");
  
  /**
  * Set
  */
  exports.set = function (mockInstance, key, value, callback) {
  
   mockInstance.storage[key] = Item.createString(value);
  
   mockInstance._callCallback(callback, null, "OK");
  };
  
  /**
  * Ping
  */
  ...

module redis-mock.keys

function redis-mock.keys (mockInstance, pattern, callback)

• description and source-code

  keys = function (mockInstance, pattern, callback) {
    var regex = patternToRegex(pattern);
    var keys = [];
  
    for (var key in mockInstance.storage) {
      if (regex.test(key)) {
        keys.push(key);
      }
    }
  
    mockInstance._callCallback(callback, null, keys);
  }

• example usage

  ...
   */
  exports.punsubscribe = function () {
  var self = this
    , subcriptions = arguments;
  
  // Unsubscribe from ALL channels
  if (!arguments.length) {
    subcriptions = Object.keys(self.psubscriptions);
    this.pub_sub_mode = false;
  }
  
  for (var i = 0; i < subcriptions.length; i++) {
    if ('string' == typeof arguments[i]) {
      // Event on next tick to emulate an actual server call
      var channelName = arguments[i];
  ...

function redis-mock.keys.del (mockInstance, keys, callback)

• description and source-code

  del = function (mockInstance, keys, callback) {
  
    if (!(keys instanceof Array)) {
      keys = [keys];
    }
  
    var keysDeleted = 0;
  
    for (var i = 0; i < keys.length; i++) {
  
      if (keys[i] in mockInstance.storage) {
  
        delete mockInstance.storage[keys[i]];
        keysDeleted++;
  
      }
    }
  
    mockInstance._callCallback(callback, null, keysDeleted);
  }

• example usage

  ...
  redismock = require('redis');
  }
  
  describe("del", function () {
  
  it("should do nothing with non-existant keys", function (done) {
    var r = redismock.createClient();
    r.del(["key1", "key2", "key3"], function (err, result
  ) {
      result.should.equal(0);
      r.del("key4", function (err, result) {
        result.should.equal(0);
        r.end(true);
        done();
      });
    });
  ...

function redis-mock.keys.exists (mockInstance, key, callback)

• description and source-code

  exists = function (mockInstance, key, callback) {
  
    var result = key in mockInstance.storage ? 1 : 0;
  
    mockInstance._callCallback(callback, null, result);
  }

• example usage

  ...
  
  describe("exists", function () {
  
    it("should return 0 for non-existing keys", function (done) {
  
      var r = redismock.createClient();
  
      r.exists("test", function (err, result) {
  
  result.should.equal(0);
  
  r.end(true);
  
  done();
  ...

function redis-mock.keys.expire (mockInstance, key, seconds, callback)

• description and source-code

  expire = function (mockInstance, key, seconds, callback) {
  
    var result = 0;
  
    var obj = mockInstance.storage[key];
  
    if (obj) {
      var now = new Date().getTime();
      var milli = Math.min(seconds*1000, Math.pow(2, 31) - 1);
  
      if (mockInstance.storage[key]._expire) {
        clearTimeout(mockInstance.storage[key]._expire);
      }
  
      mockInstance.storage[key].expires = new Date(now + milli);
      mockInstance.storage[key]._expire = setTimeout(function() {
        delete mockInstance.storage[key];
      }, milli);
  
      result = 1;
    }
  
    mockInstance._callCallback(callback, null, result);
  }

• example usage

  ...
  
  });
  
  describe("expire", function () {
  
  it("should return 0 for non-existing key", function (done) {
    var r = redismock.createClient();
    r.expire("test", 10, function (err, result) {
      result.should.equal(0);
      r.end(true);
      done();
    });
  });
  
  it("should return 1 when timeout set on existing key", function (done) {
  ...

function redis-mock.keys.ttl (mockInstance, key, callback)

• description and source-code

  ttl = function (mockInstance, key, callback) {
    var result = 0;
  
    var obj = mockInstance.storage[key];
  
    if (obj) {
      var now = new Date().getTime();
      var expires = mockInstance.storage[key].expires instanceof Date ? mockInstance.storage[key].expires.getTime() : -1;
      var seconds = (expires - now) / 1000;
  
      if (seconds > 0) {
        result = seconds;
      } else {
        result = -1;
      }
  
    } else {
      result = -2;
    }
  
    mockInstance._callCallback(callback, null, result);
  }

• example usage

  ...
      r.set("test", "test", function (err, result) {
  
        r.expire("test", 100, function (err, result) {
  
          result.should.equal(1);
  
          setTimeout(function () {
            r.ttl("test", function (err, ttl) {
  if (err) {
    done(err);
  }
  
  ttl.should.be.within(1, 99);
  
  r.del("test");
  ...

module redis-mock.list

function redis-mock.list.blpop (mockInstance, keys, timeout, callback)

• description and source-code

  blpop = function (mockInstance, keys, timeout, callback) {
    bpop.call(this, Item._list.prototype.lpop, mockInstance, keys, timeout, callback);
  }

• example usage

  ...
  
  describe("blpop", function () {
  
    it("should block until the end of the timeout", function (done) {
  var r = redismock.createClient();
  var time = false;
  
  r.blpop("foo8", 1, function (err, result) {
    should.not.exist(result);
    time.should.equal(true);
  
    done();
  
  });
  ...

function redis-mock.list.brpop (mockInstance, keys, timeout, callback)

• description and source-code

  brpop = function (mockInstance, keys, timeout, callback) {
    bpop.call(this, Item._list.prototype.rpop, mockInstance, keys, timeout, callback);
  }

• example usage

  ...
  });
  
  describe("brpop", function () {
  
    it("should block until the end of the timeout", function (done) {
  var r = redismock.createClient();
  var time = false;
  r.brpop("foo", 1, function (err, result) {
    should.not.exist(result);
    time.should.equal(true);
    done();
  });
  
  setTimeout(function () {
    time = true;
  ...

function redis-mock.list.lindex (mockInstance, key, index, callback)

• description and source-code

  lindex = function (mockInstance, key, index, callback) {
    var val = null;
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== "list") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
  
      if (index < 0 && -mockInstance.storage[key].value.length <= index) {
        val = mockInstance.storage[key].value[mockInstance.storage[key].value.length + index];
      } else if (mockInstance.storage[key].value.length > index) {
        val = mockInstance.storage[key].value[index];
      }
    }
    mockInstance._callCallback(callback, null, val);
  }

• example usage

  ...
    var keyUndefined = "keyUndefined";
    var testValues = [1, 2, 3, 4, 5];
  
    it("getting index of non exisiting list", function (done) {
  
      var r = redismock.createClient();
  
      r.lindex(keyUndefined, 0, function (err, result) {
  
        should.not.exist(result);
  
        r.lindex(keyUndefined, 12, function (err, result) {
  
  should.not.exist(result);
  ...

function redis-mock.list.llen (mockInstance, key, callback)

• description and source-code

  llen = function (mockInstance, key, callback) {
    var length = mockInstance.storage[key] ? mockInstance.storage[key].value.length : 0;
    mockInstance._callCallback(callback, null, length);
  }

• example usage

  ...
  var testKey = "myKey3";
  var testValues = [1, 2, 3, 4, 5];
  var testValue = 10;
  it("should return 0", function (done) {
  
    var r = redismock.createClient();
  
    r.llen(testKey, function (err, result) {
      result.should.equal(0);
      r.end(true);
      done();
    });
  });
  
  it("should return 5 and evolve", function (done) {
  ...

function redis-mock.list.lpop (mockInstance, key, callback)

• description and source-code

  lpop = function (mockInstance, key, callback) {
    pop.call(this, Item._list.prototype.lpop, mockInstance, key, callback);
  }

• example usage

  ...
  
    it('should pop at the front of the list', function () {
      var item = RedisItem.createList();
  
      item.type.should.equal("list");
      item.expires.should.equal(-1);
      item.value = ['a', 'b', 'c'];
      item.lpop().should.eql('a');
    });
  });
  ...

function redis-mock.list.lpush ()

• description and source-code

  lpush = function () {
    push(Item._list.prototype.lpush, arguments);
  }

• example usage

  ...
  it('should push at the front of the list', function () {
    var elt = "foo";
    var elt2 = true;
    var item = RedisItem.createList();
  
    item.type.should.equal("list");
    item.expires.should.equal(-1);
    item.lpush([elt]);
    item.lpush([elt2]);
    item.value.should.eql([elt2 + '', elt]);
  });
  
  it('should pop at the back of the list', function () {
    var item = RedisItem.createList();
  ...

function redis-mock.list.lpushx (mockInstance, key, value, callback)

• description and source-code

  lpushx = function (mockInstance, key, value, callback) {
    pushx(Item._list.prototype.lpush, mockInstance, key, value, callback);
  }

• example usage

  ...
  describe("lpushx", function (argument) {
    var testKey = "myKey9";
  
    it("tries to push on empty list", function (done) {
  
      var r = redismock.createClient();
  
      r.lpushx(testKey, 3, function (err, result) {
  
        result.should.equal(0);
  
        r.lindex(testKey, 0, function (err, result) {
  
  should.not.exist(result);
  ...

function redis-mock.list.lrange (mockInstance, key, startIndex, stopIndex, callback)

• description and source-code

  lrange = function (mockInstance, key, startIndex, stopIndex, callback) {
    var val = [];
    var index1 = startIndex;
    var index2 = stopIndex;
  
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== "list") {
        return mockInstance._callCallback(callback,
          new Error("ERR Operation against a key holding the wrong kind of value"));
      }
  
      index1 = index1 >= 0 ? index1 : Math.max(mockInstance.storage[key].value.length + index1, 0);
      index2 = index2 >= 0 ? index2 : Math.max(mockInstance.storage[key].value.length + index2, 0);
      val = mockInstance.storage[key].value.slice(index1, index2 + 1);
    }
    mockInstance._callCallback(callback, null, val);
  }

• example usage

  ...
  var key2 = "lrange2";
  var key3 = "lrange3";
  var keyU = "keyMissing";
  var testValues = [1, 2, 3, 4, 5];
  
  it("getting a non-exisiting list", function (done) {
    var r = redismock.createClient();
    r.lrange(keyU, 0, -1, function (err, result) {
      result.should.be.an.Array().and.have.lengthOf(0);
      r.end(true);
      done();
    });
  });
  
  it("getting positive indexes of exisiting list", function (done) {
  ...

function redis-mock.list.lset (mockInstance, key, index, value, callback)

• description and source-code

  lset = function (mockInstance, key, index, value, callback) {
    var res = "OK";
    var len = -1;
    if (!mockInstance.storage[key]) {
      return mockInstance._callCallback(callback,
        new Error("ERR no such key"));
    }
    if (mockInstance.storage[key].type !== "list") {
      return mockInstance._callCallback(callback,
        new Error("ERR Operation against a key holding the wrong kind of value"));
    }
    len = mockInstance.storage[key].value.length;
    if (len <= index || -len > index) {
      return mockInstance._callCallback(callback,
        new Error("ERR index out of range"));
    }
    if (index < 0) {
      mockInstance.storage[key].value[len + index] = Item._stringify(value);
    } else {
      mockInstance.storage[key].value[index] = Item._stringify(value);
    }
    mockInstance._callCallback(callback, null, res);
  }

• example usage

  ...
    var keyUndefined2 = "keyUndefined2";
    var testValues = [1, 2, 3, 4, 5];
  
    it("changing value of non exisiting list", function (done) {
  
  var r = redismock.createClient();
  
  r.lset(keyUndefined, 0, 1, function (err, result) {
    err.message.should.equal("ERR no such key");
    should.not.exist(result);
  
    r.end(true);
  
    done();
  });
  ...

function redis-mock.list.rpop (mockInstance, key, callback)

• description and source-code

  rpop = function (mockInstance, key, callback) {
    pop.call(this, Item._list.prototype.rpop, mockInstance, key, callback);
  }

• example usage

  ...
  
    it('should pop at the back of the list', function () {
  var item = RedisItem.createList();
  
  item.type.should.equal("list");
  item.expires.should.equal(-1);
  item.value = ['a', 'b', 'c'];
  item.rpop().should.eql('c');
    });
  
    it('should pop at the front of the list', function () {
  var item = RedisItem.createList();
  
  item.type.should.equal("list");
  item.expires.should.equal(-1);
  ...

function redis-mock.list.rpush ()

• description and source-code

  rpush = function () {
    push(Item._list.prototype.rpush, arguments);
  }

• example usage

  ...
  it('should push at the back of the list', function () {
    var elt = "foo";
    var elt2 = true;
    var item = RedisItem.createList();
  
    item.type.should.equal("list");
    item.expires.should.equal(-1);
    item.rpush([elt]);
    item.rpush([elt2]);
    item.value.should.eql([elt, elt2 + '']);
  });
  
  it('should push at the front of the list', function () {
    var elt = "foo";
    var elt2 = true;
  ...

function redis-mock.list.rpushx (mockInstance, key, value, callback)

• description and source-code

  rpushx = function (mockInstance, key, value, callback) {
    pushx(Item._list.prototype.rpush, mockInstance, key, value, callback);
  }

• example usage

  ...
  describe("rpushx", function (argument) {
    var testKey = "myKey8";
  
    it("tries to push on empty list", function (done) {
  
      var r = redismock.createClient();
  
      r.rpushx(testKey, 3, function (err, result) {
  
        result.should.equal(0);
  
        r.lindex(testKey, 0, function (err, result) {
  
  should.not.exist(result);
  ...

module redis-mock.pubsub

function redis-mock.pubsub.psubscribe ()

• description and source-code

  psubscribe = function () {
    var self = this;
    if (!arguments.length) { return; }
    this.pub_sub_mode = true;
  
    for (var i = 0; i < arguments.length; i++) {
      if ('string' == typeof arguments[i]) {
        // Event on next tick to emulate an actual server call
        var channelName = arguments[i];
        process.nextTick(function () {
          self.psubscriptions[channelName] = patternToRegex(channelName);
          self.emit('psubscribe', channelName);
        });
      }
    }
  }

• example usage

  ...
  });
  
  r.on("punsubscribe", function (ch) {
    should.equal(ch, channelName);
    r.end(true);
    done();
  });
  r.psubscribe(channelName);
    });
  
    it("suscribing and publishing with the same connection should make an error", function (done) {
  var channelName = "testchannel";
  var otherChannel = "otherchannel";
  
  var r = redismock.createClient();
  ...

function redis-mock.pubsub.publish (mockInstance, channel, msg)

• description and source-code

  publish = function (mockInstance, channel, msg) {
  
    this.pub_sub_mode = true;
    process.nextTick(function () {
      if ((typeof msg == "object") && (msg !== null)) {
        msg = JSON.stringify(msg);
      }
      mockInstance.emit('message', channel, msg);
    });
  }

• example usage

  ...
    var otherChannel = "otherchannel";
  
    var r = redismock.createClient();
    r.subscribe(channelName);
  
    try {
      (function () {
        r.publish(otherChannel, "");
      }).should.throwError();
    } catch (e) {
      r.end(true);
  
      done();
    }
  });
  ...

function redis-mock.pubsub.punsubscribe ()

• description and source-code

  punsubscribe = function () {
    var self = this
      , subcriptions = arguments;
  
    // Unsubscribe from ALL channels
    if (!arguments.length) {
      subcriptions = Object.keys(self.psubscriptions);
      this.pub_sub_mode = false;
    }
  
    for (var i = 0; i < subcriptions.length; i++) {
      if ('string' == typeof arguments[i]) {
        // Event on next tick to emulate an actual server call
        var channelName = arguments[i];
        process.nextTick(function () {
          delete self.psubscriptions[channelName];
          self.emit('punsubscribe', channelName);
        });
      }
    }
    // TODO: If this was the last subscription, pub_sub_mode should be set to false
  }

• example usage

  ...
  var channelName = "testchannel";
  
  should.exist(r.psubscribe);
  should.exist(r.punsubscribe);
  
  r.on("psubscribe", function (ch) {
    should.equal(ch, channelName);
    r.punsubscribe("testchannel");
  });
  
  r.on("punsubscribe", function (ch) {
    should.equal(ch, channelName);
    r.end(true);
    done();
  });
  ...

function redis-mock.pubsub.subscribe ()

• description and source-code

  subscribe = function () {
  
    var self = this;
  
    if (!arguments.length) {
      return;
    }
  
    this.pub_sub_mode = true;
  
    for (var i = 0; i < arguments.length; i++) {
  
      if ('string' == typeof arguments[i]) {
  
        // Event on next tick to emulate an actual server call
        var channelName = arguments[i];
        process.nextTick(function () {
          self.subscriptions[channelName] = true;
          // TODO Should also send length of subscriptions here
          self.emit('subscribe', channelName);
        });
      }
    }
  }

• example usage

  ...
    should.equal(ch, channelName);
  
    r.end(true);
  
    done();
  });
  
  r.subscribe(channelName);
    });
  
    it("should psubscribe and punsubscribe to a channel", function (done) {
  var r = redismock.createClient();
  var channelName = "testchannel";
  
  should.exist(r.psubscribe);
  ...

function redis-mock.pubsub.unsubscribe ()

• description and source-code

  unsubscribe = function () {
  
    var self = this
      , subcriptions = arguments;
  
    // TODO: Unsubscribe from ALL channels
    if (!arguments.length) {
      subcriptions = self.subscriptions.map(function (__, subscription) {
        return subscription;
      })
    }
  
    for (var i = 0; i < subcriptions.length; i++) {
  
      if ('string' == typeof arguments[i]) {
  
        // Event on next tick to emulate an actual server call
        var channelName = arguments[i];
        process.nextTick(function () {
          self.subscriptions[channelName] = false;
          delete self.subscriptions[channelName];
          self.emit('unsubscribe', channelName);
        });
      }
    }
  
    // TODO: If this was the last subscription, pub_sub_mode should be set to false
    this.pub_sub_mode = false;
  }

• example usage

  ...
      should.exist(r.unsubscribe);
  
      var channelName = "testchannel";
  
      r.on("subscribe", function (ch) {
  
  should.equal(ch, channelName);
  r.unsubscribe("testchannel");
      });
  
      r.on("unsubscribe", function (ch) {
  
  should.equal(ch, channelName);
  
  r.end(true);
  ...

module redis-mock.server

function redis-mock.server.auth (mockInstance, password, callback)

• description and source-code

  function auth(mockInstance, password, callback) {
    mockInstance._callCallback(callback, null, 'OK');
  }

• example usage

  ...
  
  });
  
  describe("auth", function () {
    it("should always succeed and call back", function (done) {
      var r = redismock.createClient();
  
      r.auth("secret", function (err, result) {
        result.should.equal('OK');
        done();
        r.end(true); //Moved this after the done() call. For some reason, calling `end()` beforehand causes this test to fail.
      });
    });
  });
  ...

function redis-mock.server.flushall (mockInstance, callback)

• description and source-code

  flushall = function (mockInstance, callback) {
    mockInstance.storage = {};
  
    mockInstance._callCallback(callback, null, 'OK');
  }

• example usage

  n/a

function redis-mock.server.flushdb (mockInstance, callback)

• description and source-code

  flushdb = function (mockInstance, callback) {
    mockInstance.storage = {};
  
    mockInstance._callCallback(callback, null, 'OK');
  }

• example usage

  ...
  describe("flushdb", function () {
  
    it("should clean database", function (done) {
  
      var r = redismock.createClient();
  
      r.set("foo", "bar", function (err, result) {
        r.flushdb(function (err, result) {
          result.should.equal("OK");
  
          r.exists("foo", function (err, result) {
  
  result.should.be.equal(0);
  
  r.end(true);
  ...

module redis-mock.set

function redis-mock.set.sadd (mockInstance, key, members, callback)

• description and source-code

  sadd = function (mockInstance, key, members, callback) {
    if (mockInstance.storage[key] && mockInstance.storage[key].type !== 'set') {
      var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
      return mockInstance._callCallback(callback, err);
    }
  
    mockInstance.storage[key] = mockInstance.storage[key] || new Item.createSet();
  
    var set = mockInstance.storage[key].value;
    var addCount = 0;
    for (var i = 0; i < members.length; i++) {
      if (set.indexOf(Item._stringify(members[i])) < 0) {
        set.push(Item._stringify(members[i]));
        addCount++;
      }
    }
  
    mockInstance._callCallback(callback, null, addCount);
  }

• example usage

  ...
    redismock = require('redis');
  }
  
  describe('sadd', function () {
  
    it('should add a member to the set', function (done) {
      var r = redismock.createClient();
      r.sadd('foo', 'bar', function (err, result) {
        result.should.eql(1);
  
        r.smembers('foo', function (err, result) {
  result.should.eql(['bar']);
  
  r.end(true);
  done();
  ...

function redis-mock.set.scard (mockInstance, key, callback)

• description and source-code

  scard = function (mockInstance, key, callback) {
    var count = 0;
  
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== 'set') {
        var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
        return mockInstance._callCallback(callback, err);
      } else {
        var set = mockInstance.storage[key].value;
        count = set.length;
      }
    }
  
    mockInstance._callCallback(callback, null, count);
  }

• example usage

  ...
  // TODO: Add tests of SMEMBERS
  
  describe('scard', function () {
  
  it('should return the number of elements', function (done) {
    var r = redismock.createClient();
    r.sadd('foo', 'bar', 'baz', function (err, result) {
      r.scard('foo', function (err, result) {
        result.should.eql(2);
        r.end(true);
        done();
      });
    });
  });
  ...

function redis-mock.set.sismember (mockInstance, key, member, callback)

• description and source-code

  sismember = function (mockInstance, key, member, callback) {
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== 'set') {
        var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
        return mockInstance._callCallback(callback, err);
      }
    }
    member = Item._stringify(member);
    var count = (mockInstance.storage[key].value.indexOf(member) > -1) ? 1 : 0;
    mockInstance._callCallback(callback, null, count);
  }

• example usage

  ...
  
  describe('sismember', function () {
  
    it('should test if member exists', function (done) {
  
      var r = redismock.createClient();
      r.sadd('foo2', 'bar', 'baz', 'qux', function (err, result) {
        r.sismember('foo2', 'bar', function (err, result) {
          result.should.eql(1);
          done();
        });
      });
    });
  
  });
  ...

function redis-mock.set.smembers (mockInstance, key, callback)

• description and source-code

  smembers = function (mockInstance, key, callback) {
    var members = null;
  
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== 'set') {
        var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
        return mockInstance._callCallback(callback, err);
      } else {
        members = mockInstance.storage[key].value;
      }
    }
  
    mockInstance._callCallback(callback, null, members);
  }

• example usage

  ...
  describe('sadd', function () {
  
  it('should add a member to the set', function (done) {
    var r = redismock.createClient();
    r.sadd('foo', 'bar', function (err, result) {
      result.should.eql(1);
  
      r.smembers('foo', function (err, result) {
        result.should.eql(['bar']);
  
        r.end(true);
        done();
      });
    });
  });
  ...

function redis-mock.set.srem (mockInstance, key, members, callback)

• description and source-code

  srem = function (mockInstance, key, members, callback) {
    var remCount = 0;
  
    if (mockInstance.storage[key]) {
  
      if (mockInstance.storage[key].type !== 'set') {
        var err = new Error('WRONGTYPE Operation against a key holding the wrong kind of value');
        return mockInstance._callCallback(callback, err);
  
      } else {
        var set = mockInstance.storage[key].value;
        for (var i = 0; i < members.length; i++) {
          for (var j = 0; j < set.length; j++) {
            if (set[j] == Item._stringify(members[i])) {
              set.splice(j, 1);
              remCount++;
            }
          }
        }
      }
    }
  
    mockInstance._callCallback(callback, null, remCount);
  }

• example usage

  ...
  
  describe('srem', function () {
  
    it('should remove a member from the set', function (done) {
      var r = redismock.createClient();
      r.sadd('foo', 'bar', 'baz', 'qux', function (err, result) {
  
        r.srem('foo', 'bar', function (err, result) {
  result.should.eql(1);
  
  r.smembers('foo', function (err, result) {
    result.should.be.instanceof(Array);
    result.should.have.length(2);
    result.should.containEql('baz');
    result.should.containEql('qux');
  ...

module redis-mock.sortedset

function redis-mock.sortedset.zadd (mockInstance, key)

• description and source-code

  zadd = function (mockInstance, key) {
  
    var len = arguments.length;
    if (len <= 3) {
      return
    }
    var callback = helpers.parseCallback(arguments);
    if (!validKeyType(mockInstance, key, callback)) {
      return
    }
    // init key
    initKey(mockInstance, key);
  
    // declare opts
    var nx = false, xx = false, ch = false, incr = false;
    var start = 2, count = 0;
  
    for (var i=start; i < len; i++) {
      var opt = arguments[i];
      opt = opt.toString().toLowerCase();
      // Don't update already existing elements. Always add new elements.
      if (opt === 'nx') {
        nx = true;
        continue;
      }
      // Only update elements that already exist. Never add elements.
      if (opt === 'xx') {
        xx = true;
        continue;
      }
      // Total number of elements changed
      if (opt === 'ch') {
        ch = true;
        continue;
      }
      if (opt === 'incr') {
        incr = true;
        continue;
      }
      start = i;
      break;
  
    }
  
    for (var i = start; i < len; i += 2) {
      // hold the score and make sure it isn't an opt
      var score = arguments[i];
  
      // did we reach the end?
      if (len <= (i + 1)) {
          break;
      }
      var member = Item._stringify(arguments[i + 1]);
      var existingScore = mockInstance.storage[key].value[member];
      var exists = existingScore != undefined;
  
      // process opts
      if ((nx && exists) || (xx && !exists)) {
        continue;
      }
      // convert score to string
      score = score.toString();
  
      // updating score if memeber doesn't exist
      // or if ch = true and score changes
      if (!exists || (ch && existingScore != score)) {
        count += 1;
      }
  
      // do we need to incr (existing score + score)?
      if (incr && existingScore) {
        score = parseFloat(existingScore) + parseFloat(score);
        score = String(score);
      }
  
      // update score
      mockInstance.storage[key].value[member] = score;
  
      // only one member is allowed update
      // if we have an incr
      // this shold behave the same as zincrby
      // so return the score instead of the updatedCount;
      if (incr) {
        count = score;
        break;
      }
    }
  
    if (callback) {
      mockInstance._callCallback(callback, null, count);
    }
  }

• example usage

  ...
      3, 'm3',
    ];
  
    var aLen = args.length;
    var mLen = aLen / 2;
    it("should add scores and members", function (done) {
      var r = redismock.createClient();
      r.zadd([testKey1].concat(args), function(err, result) {
        result.should.equal(mLen);
        // should only add new members
        r.zadd([testKey1, 'nx', 1, 'm1', 0, 'm4'], function(err, result) {
  result.should.equal(1);
  
  // only update existing members
  // this won't bump the return count
  ...

function redis-mock.sortedset.zcard (mockInstance, key, callback)

• description and source-code

  zcard = function (mockInstance, key, callback) {
    var len = arguments.length;
    if (len < 1) {
      return
    }
    if (callback == undefined) {
      callback = mockCallback;
    }
    if (!validKeyType(mockInstance, key, callback)) {
      return
    }
    initKey(mockInstance, key);
    var count = Object.keys(mockInstance.storage[key].value).length;
    mockInstance._callCallback(callback, null, count);
  }

• example usage

  ...
    it("should add scores and members", function (done) {
      var r = redismock.createClient();
  
      r.zadd(testKey1, testScore1, testMember1, testScore2, testMember2,
        function(err, result) {
          result.should.equal(2);
  
          r.zcard(testKey1, function(err, result) {
            result.should.equal(2);
            done();
          });
      });
    });
  });
  ...

function redis-mock.sortedset.zcount (mockInstance, key, min, max, callback)

• description and source-code

  zcount = function (mockInstance, key, min, max, callback) {
    var parse = function(err, result) {
      if (err) {
        return mockInstance._callCallback(callback, err);
      }
      mockInstance._callCallback(callback, null, result.length);
    }
    exports.zrangebyscore(mockInstance, key, min, max, parse);
  }

• example usage

  ...
  var mLen = aLen / 2;
  
  it("should return the inclusive min & max count", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      result.should.equal(mLen);
  
      r.zcount([testKey1, '0', '5'], function(err, result) {
        should(result).equal(mLen);
        done();
      });
  
    });
  });
  ...

function redis-mock.sortedset.zincrby (mockInstance, key, increment, member, callback)

• description and source-code

  zincrby = function (mockInstance, key, increment, member, callback) {
    var len = arguments.length;
    if (len < 4) {
      return
    }
    if (callback == undefined) {
      callback = mockCallback;
    }
    if (!validKeyType(mockInstance, key, callback)) {
      return
    }
    initKey(mockInstance, key);
    member = Item._stringify(member);
    var s = mockInstance.storage[key].value[member];
    var score = parseFloat( s !== undefined ? s : '0');
    increment = parseFloat(String(increment));
    score += increment;
    score = String(score);
    mockInstance.storage[key].value[member] = score;
    mockInstance._callCallback(callback, null, score);
  }

• example usage

  ...
  var testKey1 = "zincrbyKey1";
  var testKey2 = "zincrbyKey2";
  
  it("should add and increment a member", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1,  1, 'm1'], function(err, result) {
      result.should.equal(1);
      r.zincrby([testKey1, 5, 'm1'], function(err, result) {
        should(result).equal('6');
        done();
      });
    });
  });
  
  it("should increment a non-existing member", function (done) {
  ...

function redis-mock.sortedset.zrange (mockInstance, key, start, stop, withscores, callback)

• description and source-code

  zrange = function (mockInstance, key, start, stop, withscores, callback) {
    getRange(mockInstance, key, start, stop, withscores, callback, false);
  }

• example usage

  ...
  var aLen = args.length;
  var mLen = aLen / 2;
  
  it("should return everything withscores", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      result.should.equal(mLen);
      r.zrange([testKey1, '0', '-1', 'withscores'], function
  (err, result) {
        should(result[0]).equal('m1');
        should(result[1]).equal('1');
        should(result.length).equal(aLen);
        done();
      });
    });
  });
  ...

function redis-mock.sortedset.zrangebyscore ( mockInstance, key, min, max, withscores, limit, offset, count, callback)

• description and source-code

  zrangebyscore = function ( mockInstance, key, min, max, withscores, limit, offset, count, callback) {
  
    getRangeByScore(
      mockInstance,
      key,
      min,
      max,
      withscores,
      limit,
      offset,
      count,
      callback,
      false);
  
  }

• example usage

  ...
  exports.zcount = function(mockInstance, key, min, max, callback) {
  var parse = function(err, result) {
    if (err) {
      return mockInstance._callCallback(callback, err);
    }
    mockInstance._callCallback(callback, null, result.length);
  }
  exports.zrangebyscore(mockInstance, key, min, max, parse);
  }
  
  // ZINCRBY key increment member
  // Increment the score of a member in a sorted set
  exports.zincrby = function(mockInstance, key, increment, member, callback) {
  var len = arguments.length;
  if (len < 4) {
  ...

function redis-mock.sortedset.zrank (mockInstance, key, member, callback)

• description and source-code

  zrank = function (mockInstance, key, member, callback) {
    getRank(mockInstance, key, member, callback, false);
  }

• example usage

  ...
    1.3, 'm1.3',
    1.4, 'm1.4',
    1.5, 'm1.5'
  ];
  it("should return the rank for a member", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      r.zrank(testKey1, 'm1.1', function(err, result) {
        result.should.equal(1);
        done();
      });
    });
  });
  it("should return a null rank for a missing member", function (done) {
    var r = redismock.createClient();
  ...

function redis-mock.sortedset.zrem (mockInstance, key)

• description and source-code

  zrem = function (mockInstance, key) {
    var len = arguments.length;
    if (len <= 3) {
      return
    }
  
    var callback = helpers.parseCallback(arguments);
    if (callback == undefined) {
      callback = mockCallback;
    }
    if (!validKeyType(mockInstance, key, callback)) {
      return
    }
    initKey(mockInstance, key);
    // The number of members removed from the sorted set,
    // not including non existing members.
    var count = 0;
    for (var i=2, member; i < len; i++) {
      member = arguments[i];
      if ('function' == typeof member) {
        break;
      }
      member = Item._stringify(member);
      if (mockInstance.storage[key].value[member]) {
        delete mockInstance.storage[key].value[member];
        count += 1;
      }
    }
    mockInstance._callCallback(callback, null, count);
  }

• example usage

  ...
      1.3, 'm1.3',
      1.4, 'm1.4',
      1.5, 'm1.5'
    ];
    it("should add and remove members", function (done) {
      var r = redismock.createClient();
      r.zadd([testKey1].concat(args), function(err, result) {
          r.zrem([testKey1, 'm1', 'm2'], function(err, result) {
            result.should.equal(2);
            done();
        });
      });
    });
  });
  ...

function redis-mock.sortedset.zremrangebyrank (mockInstance, key, start, stop, callback)

• description and source-code

  zremrangebyrank = function (mockInstance, key, start, stop, callback) {
  
    var deleteResults = function(err, results) {
      if (err) {
        return mockInstance._callCallback(callback, err);
      }
      var count = 0;
      for (var i=0, member; i < results.length; i++) {
        member = results[i];
        if (mockInstance.storage[key].value[member]) {
          delete mockInstance.storage[key].value[member];
          count += 1;
        }
      }
      mockInstance._callCallback(callback, null, count);
    }
    getRange(mockInstance, key, start, stop, deleteResults, false);
  }

• example usage

  ...
      1.3, 'm1.3',
      1.4, 'm1.4',
      1.5, 'm1.5'
    ];
    it("should add and remove members by rank", function (done) {
      var r = redismock.createClient();
      r.zadd([testKey1].concat(args), function(err, result) {
          r.zremrangebyrank([testKey1, '0', '1'], function(err, result
  ) {
            result.should.equal(2);
            done();
        });
      });
    });
  });
  ...

function redis-mock.sortedset.zremrangebyscore (mockInstance, key, min, max, callback)

• description and source-code

  zremrangebyscore = function (mockInstance, key, min, max, callback) {
  
    var deleteResults = function(err, results) {
      if (err) {
        return mockInstance._callCallback(callback, err);
      }
      var count = 0;
      for (var i=0, member; i < results.length; i++) {
        member = results[i];
        if (mockInstance.storage[key].value[member]) {
          delete mockInstance.storage[key].value[member];
          count += 1;
        }
      }
      mockInstance._callCallback(callback, null, count);
    }
    getRangeByScore(mockInstance, key, min, max, deleteResults, false);
  }

• example usage

  ...
      1.3, 'm1.3',
      1.4, 'm1.4',
      1.5, 'm1.5'
    ];
    it("should add and remove members by rank", function (done) {
      var r = redismock.createClient();
      r.zadd([testKey1].concat(args), function(err, result) {
          r.zremrangebyscore([testKey1, '1.1', '1.5'], function(err
  , result) {
            result.should.equal(5);
            done();
        });
      });
    });
  });
  ...

function redis-mock.sortedset.zrevrange (mockInstance, key, start, stop, withscores, callback)

• description and source-code

  zrevrange = function (mockInstance, key, start, stop, withscores, callback) {
    getRange(mockInstance, key, start, stop, withscores, callback, true);
  }

• example usage

  ...
  var aLen = args.length;
  var mLen = aLen / 2;
  
  it("should return everything withscores", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      result.should.equal(mLen);
      r.zrevrange([testKey1, '0', '-1', 'withscores'], function
  (err, result) {
        should(result[0]).equal('m3');
        should(result[1]).equal('3');
        should(result.length).equal(aLen);
        done();
      });
    });
  });
  ...

function redis-mock.sortedset.zrevrangebyscore ( mockInstance, key, max, min, withscores, limit, offset, count, callback)

• description and source-code

  zrevrangebyscore = function ( mockInstance, key, max, min, withscores, limit, offset, count, callback) {
  
    getRangeByScore(
      mockInstance,
      key,
      min,
      max,
      withscores,
      limit,
      offset,
      count,
      callback,
      true);
  }

• example usage

  ...
  var aLen = args.length;
  var mLen = aLen / 2;
  
  it("should return the inclusive min & max range withscores", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      result.should.equal(mLen);
      r.zrevrangebyscore([testKey1, '5', '0', 'withscores'
  ;], function(err, result) {
        should(result[0]).equal('m3');
        should(result[1]).equal('3');
        should(result.length).equal(aLen);
        done();
      });
    });
  });
  ...

function redis-mock.sortedset.zrevrank (mockInstance, key, member, callback)

• description and source-code

  zrevrank = function (mockInstance, key, member, callback) {
    getRank(mockInstance, key, member, callback, true);
  }

• example usage

  ...
    1.3, 'm1.3',
    1.4, 'm1.4',
    1.5, 'm1.5'
  ];
  it("should return the rank for a member", function (done) {
    var r = redismock.createClient();
    r.zadd([testKey1].concat(args), function(err, result) {
      r.zrevrank(testKey1, 'm2', function(err, result) {
        result.should.equal(1);
        done();
      });
    });
  });
  it("should return a null rank for a missing member", function (done) {
    var r = redismock.createClient();
  ...

function redis-mock.sortedset.zscore (mockInstance, key, member, callback)

• description and source-code

  zscore = function (mockInstance, key, member, callback) {
    var len = arguments.length;
    if (len < 3) {
      return
    }
    if (callback == undefined) {
      callback = mockCallback;
    }
    if (!validKeyType(mockInstance, key, callback)) {
      return
    }
    initKey(mockInstance, key);
    var score = mockInstance.storage[key].value[Item._stringify(member)];
    mockInstance._callCallback(callback, null, score);
  }

• example usage

  ...
    var testScore1 = 100.00;
    var testMember1 = JSON.stringify({'a': 'b'});
    it("should add and return member score", function (done) {
      var r = redismock.createClient();
      r.zadd(testKey1, testScore1, testMember1, function(err, result) {
        result.should.equal(1);
  
        r.zscore([testKey1, testMember1], function(err, result) {
          result.should.equal(String(100.00));
          done();
        });
      });
    });
  });
  ...

module redis-mock.strings

function redis-mock.strings.get (mockInstance, key, callback)

• description and source-code

  get = function (mockInstance, key, callback) {
  
    var value = null;
    var err = null;
  
    if (mockInstance.storage[key]) {
      if (mockInstance.storage[key].type !== "string") {
        err = new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
      } else {
        value = mockInstance.storage[key].value;
      }
    }
  
    mockInstance._callCallback(callback, err, value);
  }

• example usage

  ...
  }
  
  /**
   * Getset
   */
  exports.getset = function (mockInstance, key, value, callback) {
  
    exports.get(mockInstance, key, /*callback);,*/ function(err, oldValue) {
  if (err) {
    return mockInstance._callCallback(callback, err, null);
  }
  
  mockInstance.storage[key] = Item.createString(value);
  
  mockInstance._callCallback(callback, err, oldValue);
  ...

function redis-mock.strings.getset (mockInstance, key, value, callback)

• description and source-code

  getset = function (mockInstance, key, value, callback) {
  
    exports.get(mockInstance, key, /*callback);,*/ function(err, oldValue) {
      if (err) {
        return mockInstance._callCallback(callback, err, null);
      }
  
      mockInstance.storage[key] = Item.createString(value);
  
      mockInstance._callCallback(callback, err, oldValue);
    });
  }

• example usage

  ...
  var r;
  
  beforeEach(function () {
    r = redismock.createClient();
  });
  
  it("should return null for a non-existing key", function (done) {
    r.getset("does-not-exist", "newValue", function (err, result) {
      should.not.exist(result);
  
      r.end(true);
      done();
    });
  
  });
  ...

function redis-mock.strings.incr (mockInstance, key, callback)

• description and source-code

  incr = function (mockInstance, key, callback) {
  
    function _isInteger(s) {
      return parseInt(s, 10) == s;
    }
  
    if (!mockInstance.storage[key]) {
      var number = 0 + 1;
      exports.set(mockInstance, key, number);
      mockInstance._callCallback(callback, null, number);
  
    } else if (mockInstance.storage[key].type !== "string") {
      var err = new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
      mockInstance._callCallback(callback, err, null);
  
    } else if (_isInteger(mockInstance.storage[key].value)) {
      var number = parseInt(mockInstance.storage[key].value, 10) + 1;
      exports.set(mockInstance, key, number);
      mockInstance._callCallback(callback, null, number);
  
    } else {
      var err = new Error("ERR value is not an integer or out of range");
      mockInstance._callCallback(callback, err, null);
    }
  }

• example usage

  ...
      should.exist(multi.exists);
      should.exist(multi.hget);
    });
  
    describe("exec()", function () {
      it("should handle things without errors and callbacks", function (done) {
  var multi = r.multi();
  multi.get('foo').incr('foo');
  
  r.set('foo', 3, function () {
    multi.exec(function (err, results) {
      should(err).not.be.ok();
      should.deepEqual(results, ['3',4]);
      done();
    });
  ...

function redis-mock.strings.incrby (mockInstance, key, value, callback)

• description and source-code

  incrby = function (mockInstance, key, value, callback) {
  
    function _isInteger(s) {
      return parseInt(s, 10) == s;
    }
  
    value = parseInt(value);
  
    if (!mockInstance.storage[key]) {
      var number = 0 + value;
      exports.set(mockInstance, key, number);
      mockInstance._callCallback(callback, null, number);
  
    } else if (mockInstance.storage[key].type !== "string") {
      var err = new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
      mockInstance._callCallback(callback, err, null);
  
    } else if (_isInteger(mockInstance.storage[key].value)) {
      var number = parseInt(mockInstance.storage[key].value, 10) + value;
      exports.set(mockInstance, key, number);
      mockInstance._callCallback(callback, null, number);
  
    } else {
      var err = new Error("ERR value is not an integer or out of range");
      mockInstance._callCallback(callback, err, null);
    }
  }

• example usage

  ...
  
    it("should increment the number stored at key by 2", function (done) {
  
      var r = redismock.createClient();
  
      r.set("foo", "10", function (err, result) {
  
        r.incrby("foo", 2, function (err, result) {
  
          result.should.eql(12);
  
          r.get("foo", function (err, result) {
  
  result.should.eql("12");
  ...

function redis-mock.strings.incrbyfloat (mockInstance, key, value, callback)

• description and source-code

  incrbyfloat = function (mockInstance, key, value, callback) {
  
    function _isFloat(s) {
      return parseFloat(s, 10) == s;
    }
  
    if (!mockInstance.storage[key]) {
      var number = 0 + parseFloat(value, 10);
      exports.set(mockInstance, key, number.toString());
      mockInstance._callCallback(callback, null, number.toString());
  
    } else if (mockInstance.storage[key].type !== "string") {
      var err = new Error("WRONGTYPE Operation against a key holding the wrong kind of value");
      mockInstance._callCallback(callback, err, null);
  
    } else if (_isFloat(mockInstance.storage[key].value) && _isFloat(value)) {
      var number = parseFloat(mockInstance.storage[key].value, 10) + parseFloat(value, 10);
      exports.set(mockInstance, key, number.toString());
      mockInstance._callCallback(callback, null, number.toString());
  
    } else {
      var err = new Error("ERR value is not a valid float");
      mockInstance._callCallback(callback, err, null);
    }
  }

• example usage

  ...
  
    it("should increment the number stored at key by a float value", function (done) {
  
      var r = redismock.createClient();
  
      r.set("foo", "1.5", function (err, result) {
  
        r.incrbyfloat("foo", "0.5", function (err, result) {
  
          result.should.eql("2");
  
          r.get("foo", function (err, result) {
  
  result.should.eql("2");
  ...

function redis-mock.strings.mget (mockInstance)

• description and source-code

  mget = function (mockInstance) {
  
    var keys = [];
    var err = null;
  
    // Build up the set of keys
    if ('object' == typeof arguments[1]) {
      keys = arguments[1];
    } else {
      for (var i = 1; i < arguments.length; i++) {
        var key = arguments[i];
        if ('function' !== typeof key) {
          keys.push(key);
        }
      }
    }
  
    var values = [];
    for (var j = 0; j < keys.length; j++) {
      if (mockInstance.storage[keys[j]]) {
        if (mockInstance.storage[keys[j]].type !== 'string') {
          err = new Error("ERR Operation against key " + keys[j] + " holding wrong kind of value");
        } else {
          values.push(mockInstance.storage[keys[j]].value);
        }
      } else {
        values.push(null);
      }
    }
  
    if ('function' === typeof arguments[arguments.length - 1]) {
      mockInstance._callCallback(arguments[arguments.length - 1], err, values);
    }
  
  }

• example usage

  ...
  
      var r = redismock.createClient();
  
      r.set("multi1", "one", function (err, result) {
  
        r.set("multi3", "three", function (err, result) {
  
          r.mget("multi1", "multi2", "multi3", function (
  err, result) {
  result.should.be.ok;
  
  result[0].should.equal("one");
  
  should.not.exist(result[1]);
  
  result[2].should.equal("three");
  ...

function redis-mock.strings.ping (mockInstance, callback)

• description and source-code

  ping = function (mockInstance, callback) {
  
    mockInstance._callCallback(callback, null, "PONG");
  }

• example usage

  ...
  }
  
  describe("ping", function () {
    it("should return PONG", function (done) {
  
  var r = redismock.createClient();
  
  r.ping(function (err, result) {
    result.should.equal("PONG");
  
    r.end(true);
  
    done();
  
  });
  ...

function redis-mock.strings.set (mockInstance, key, value, callback)

• description and source-code

  set = function (mockInstance, key, value, callback) {
  
    mockInstance.storage[key] = Item.createString(value);
  
    mockInstance._callCallback(callback, null, "OK");
  }

• example usage

  ...
  /**
  * Setnx
  */
  exports.setnx = function (mockInstance, key, value, callback) {
   if (key in mockInstance.storage) {
     mockInstance._callCallback(callback, null, 0);
   } else {
     exports.set(mockInstance, key, value, /*callback);,*/ function() {
       mockInstance._callCallback(callback, null, 1);
     });
   }
  };
  
  /**
  * Get
  ...

function redis-mock.strings.setnx (mockInstance, key, value, callback)

• description and source-code

  setnx = function (mockInstance, key, value, callback) {
    if (key in mockInstance.storage) {
      mockInstance._callCallback(callback, null, 0);
    } else {
      exports.set(mockInstance, key, value, /*callback);,*/ function() {
        mockInstance._callCallback(callback, null, 1);
      });
    }
  }

• example usage

  ...
  
  describe("setnx", function () {
  
    it("should set a key", function (done) {
  
      var r = redismock.createClient();
  
      r.setnx("foo", "10", function (err, result) {
    result.should.eql(1);
  
  r.get("foo", function (err, result) {
    result.should.eql("10");
    r.end(true);
    done();
  });
  ...