@depup/fakeredis 2.0.0-depup.0

package/main.js

@@ -0,0 +1,268 @@
+"use strict";
+
+// By default fakeredis simulates a ridiculous amount of network latency
+// to help you discover race-conditions when testing multi-client setups.
+// Instantiate your 'clients' with a truthy .fast option,
+// or set it here globally to make things go a bit faster.
+
+exports.fast = false;
+
+var index = require("redis")
+  , Backend = require("./lib/backend").Backend
+  , Connection = require("./lib/connection").Connection
+  , helpers = require("./lib/helpers")
+
+  , backends = {}
+  , RedisClient = index.RedisClient
+
+  , anon = 0;
+
+
+// Re-export redis exports.
+
+exports.RedisClient = index.RedisClient;
+exports.Multi = index.Multi;
+exports.print = index.print;
+exports.backends = backends;
+
+// Overriden client factory.
+
+exports.createClient = function(port, host, options) {
+  if (arguments.length == 1 && typeof port == "object") { 
+    options = port;
+    if (options.port || options.host) {
+      port = options.port;
+      host = options.host;
+    }
+    if (options.url || options.path) { 
+      host = options.url || options.path;
+      port = "";
+    }
+  }
+  var id = !port && !host ? 'fake_' + (++anon) : (host || "") + ((port) ? ":" + port : null || "")
+    , lat = options && options.fast || exports.fast ? 1 : null
+    , c = new Connection(backends[id] || (backends[id] = new Backend), lat, lat)
+    , real_create_stream = RedisClient.prototype.create_stream
+    , returnBuffers = options && options.return_buffers
+    , detectBuffers = options && options.detect_buffers;
+
+  // Mock create_stream to create a new RedisClient without creating a socket
+  RedisClient.prototype.create_stream = function () {
+    this.connected = true;
+    this.ready = true;
+  };
+
+  var cl = new RedisClient(/* options */)
+
+  // Replace the mocked create_stream function again with the original one
+  RedisClient.prototype.create_stream = real_create_stream;
+
+  if (options && options.verbose)
+    c.verbose = true;
+
+  cl.end = function() {
+    cl.send_command = function(command) {
+      throw new Error("fakeredis: You've closed this connection with .end(), cannot " + command);
+    };
+  };
+
+  cl.send_command = function(command, args, callback) {
+
+    // Interpret arguments, copy-paste from mranney/redis/index.js for best compat.
+    if (typeof command !== "string") {
+      throw new Error("First argument to send_command must be the command name string, not " + typeof command);
+    }
+
+    if (Array.isArray(args)) {
+      if (typeof callback === "function") {
+        // probably the fastest way:
+        //     client.command([arg1, arg2], cb);  (straight passthrough)
+        //         send_command(command, [arg1, arg2], cb);
+      } else if (! callback) {
+        // most people find this variable argument length form more convenient, but it uses arguments, which is slower
+        //     client.command(arg1, arg2, cb);   (wraps up arguments into an array)
+        //       send_command(command, [arg1, arg2, cb]);
+        //     client.command(arg1, arg2);   (callback is optional)
+        //       send_command(command, [arg1, arg2]);
+        //     client.command(arg1, arg2, undefined);   (callback is undefined)
+        //       send_command(command, [arg1, arg2, undefined]);
+        var last_arg_type = typeof args[args.length - 1];
+        if (last_arg_type === "function" || last_arg_type === "undefined") {
+          callback = args.pop();
+        }
+      } else {
+        throw new Error("send_command: last argument must be a callback or undefined");
+      }
+    } else {
+      throw new Error("send_command: second argument must be an array");
+    }
+
+    // if the last argument is an array, expand it out.  This allows commands like this:
+    //     client.command(arg1, [arg2, arg3, arg4], cb);
+    //  and converts to:
+    //     client.command(arg1, arg2, arg3, arg4, cb);
+    // which is convenient for some things like sadd
+    if (Array.isArray(args[args.length - 1])) {
+      args = args.slice(0, - 1).concat(args[args.length - 1]);
+    }
+
+
+    // Arg check.
+
+    var useBuffers = returnBuffers;
+    var i, n;
+    n = args.length;
+    for (i = 0; i < n; i++) {
+      var arg = args[i];
+
+      // buf support
+      if (Buffer.isBuffer(arg)) {
+        args[i] = packageBuffer(arg);
+        if (detectBuffers)
+          useBuffers = true;
+      }
+
+      // lint
+      else if (typeof arg !== 'string' && typeof arg !== 'number') {
+        var err = new Error("fakeredis/lint: Argument #" + i + " for " + command + " is not a String, Buffer or Number: " + arg);
+        if (callback)
+          return callback(err);
+        else
+          throw err;
+      }
+    }
+
+
+    // Callback middleware.
+
+    if (callback) {
+
+      // hgetall sugar
+      if (/^hgetall/i.test(command))
+        callback = makeReplyToObjectAdaptor(callback);
+
+      // buffer support
+      callback = makeUnpackageBuffersAdaptor(useBuffers, callback);
+    }
+
+
+    //
+
+    c.push(this, command, args, callback);
+  };
+
+  cl.pushMessage = cl.emit.bind(cl);
+
+  (function() {
+    var prop;
+    for (prop in helpers)
+      cl[prop] = helpers[prop];
+  }
+  ());
+
+
+  // Schedule some events.
+
+  process.nextTick(function() {
+    cl.ready = true;
+    cl.emit('ready');
+  });
+
+
+  //
+  return cl;
+};
+
+
+//
+
+function makeReplyToObjectAdaptor(callback) {
+  return function(err, data) {
+    if (!err && data)
+      data = reply_to_object(data);
+
+    callback(err, data);
+  };
+}
+
+function makeUnpackageBuffersAdaptor(returnAsBuffers, callback) {
+  return function(err, data) {
+    if (!err)
+      data = returnAsBuffers
+        ? unpackageBuffersAsObjects(data)
+        : unpackageBuffersAsStrings(data);
+
+    callback(err, data);
+  };
+}
+
+
+// Helpers for node_redis compat.
+
+// hgetall converts its replies to an Object.  If the reply is empty, null is returned.
+function reply_to_object(reply) {
+  var obj = {}, j, jl, key, val;
+
+  if (reply.length === 0) {
+    return null;
+  }
+
+  for (j = 0, jl = reply.length; j < jl; j += 2) {
+    key = reply[j].toString();
+    val = reply[j + 1];
+    obj[key] = val;
+  }
+
+  return obj;
+}
+
+
+// I realize this is possibly the most idiotic way to add support for buffers.
+
+var BUFFER_PREFIX = "\t!bUF?!1\t";
+
+function packageBuffer(buf) {
+
+  // If possible, try storing the buffer as a utf8 string.
+  // For this to work baking the string back to a buffer must yield the exact same bytes.
+  var asString = buf.toString('utf8');
+  var enc = new Buffer(asString, 'utf8');
+  var n = enc.length;
+  if (n === buf.length) {
+    var ok = true;
+    while (n--)
+      if (buf[n] !== enc[n]) {
+        ok = false;
+        break;
+      }
+
+    if (ok)
+      return asString;
+  }
+
+  // If not possible, keep the buffer as a prefixed, base64 encoded string internally.
+  return BUFFER_PREFIX + buf.toString('base64');
+}
+
+function unpackageBuffersAsObjects(data) {
+  if (Array.isArray(data))
+    return data.map(unpackageBuffersAsObjects);
+
+  if (typeof data === 'string' && data.indexOf(BUFFER_PREFIX) === 0)
+    return new Buffer(data.substr(BUFFER_PREFIX.length), 'base64');
+  else if (data)
+    return new Buffer(data.toString(), 'utf8');
+  else
+    return null;
+}
+
+function unpackageBuffersAsStrings(data) {
+  if (Array.isArray(data))
+    return data.map(unpackageBuffersAsStrings);
+
+  if (typeof data === 'string' && data.indexOf(BUFFER_PREFIX) === 0)
+    return new Buffer(data.substr(BUFFER_PREFIX.length), 'base64').toString('utf8');
+  else
+    return data;
+}
+

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@depup/fakeredis",
+  "version": "2.0.0-depup.0",
+  "description": "Fake redis for testing, works as a drop-in replacement for node_redis (with updated dependencies)",
+  "keywords": [
+    "fakeredis",
+    "depup",
+    "updated-dependencies",
+    "security",
+    "latest",
+    "patched",
+    "test",
+    "spec",
+    "fake",
+    "redis",
+    "simulated",
+    "implementation",
+    "client"
+  ],
+  "author": "Hristo Dachev <tutini@gmail.com>",
+  "main": "./main.js",
+  "dependencies": {
+    "redis": "^5.11.0"
+  },
+  "license": "MIT",
+  "bugs": {
+    "mail": "tutini@gmail.com",
+    "url": "http://github.com/hdachev/fakeredis/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/hdachev/fakeredis.git"
+  },
+  "scripts": {
+    "test": "./runtest",
+    "coverage": "./covertest"
+  },
+  "devDependencies": {
+    "coveralls": "^2.11.6",
+    "istanbul": "^0.4.2",
+    "lcov-result-merger": "^1.0.2"
+  },
+  "depup": {
+    "changes": {
+      "redis": {
+        "from": "2.6.0-0",
+        "to": "^5.11.0"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "fakeredis",
+    "originalVersion": "2.0.0",
+    "processedAt": "2026-03-19T03:03:52.393Z",
+    "smokeTest": "passed"
+  }
+}