added more tests

Author: pasupulaphani

lib/redis_store.js

@@ -4,88 +4,51 @@ const logger = require("./logger");
 
 const debug = require("debug")("simpleRedisStore");
 
+function wrapFunc (pool, func) {
+  return pool.acquire()
+    .then((conn) => func(conn)
+        .then((result) => {
+          pool.release(conn);
+          return result;
+        })
+        .catch(err => {
+          pool.release(conn);
+          throw err;
+        }));
+}
+
 function RedisStore (name, redisOptions, poolOptions) {
 
+  if (!poolOptions) {
+    poolOptions = {};
+  }
+  poolOptions = Object.assign({
+    acquireTimeoutMillis: 50
+  }, poolOptions);
+
   const pool = new RedisPool(name, redisOptions, poolOptions);
   logger.info("Redis store created.", pool.status());
 
   this.getName = bind(pool.getName, pool);
-  this.getDB = bind(pool.getDB, pool);
-  this.status = bind(pool.status, pool);
-
-  this.get = (key) => {
-
-    return pool.acquire()
-      .then((conn) => {
-        return conn.getAsync(key)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
-  };
+  this.getRedisDB = bind(pool.getDB, pool);
+  this.getPoolStatus = bind(pool.status, pool);
 
-  this.set = (key, value) => {
-
-    return pool.acquire()
-      .then((conn) => {
-        return conn.setAsync(key, value)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
-  };
-
-  this.setex = (key, value, ttlInSeconds) => {
-
-    return pool.acquire()
-      .then((conn) => {
-        return conn.setexAsync(key, ttlInSeconds, value)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
-  };
+  this.get = (key) => wrapFunc(pool, (conn) => conn.getAsync(key));
 
-  this.del = (key) => {
+  this.set = (key, value) => wrapFunc(pool, (conn) => conn.setAsync(key, value));
 
-    return pool.acquire()
-      .then((conn) => {
-        return conn.delAsync(key)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
-  };
+  this.setex = (key, value, ttlInSeconds) => wrapFunc(pool, (conn) => conn.setexAsync(key, ttlInSeconds, value));
 
-  this.ttlInSeconds = (key) => {
+  this.del = (key) => wrapFunc(pool, (conn) => conn.delAsync(key));
 
-    return pool.acquire()
-      .then((conn) => {
-        return conn.ttlInSecondsAsync(key)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
-  };
+  this.ttlInSeconds = (key) => wrapFunc(pool, (conn) => conn.ttlInSecondsAsync(key));
 
   this.keys = (pattern) => {
     if (!pattern || pattern === "") {
       pattern = "*";
     }
 
-    return pool.acquire()
-      .then((conn) => {
-        return conn.keysAsync(pattern)
-          .then((result) => {
-            pool.release(conn);
-            return result;
-          });
-      });
+    return wrapFunc(pool, (conn) => conn.keysAsync(pattern));
   };
 
 

test/index.js

@@ -0,0 +1,118 @@
+const should = require("should");
+const Bluebird = require("bluebird");
+const RedisStore = require("../lib/redis_store");
+
+describe("redisStore", function () {
+
+  const redisOptions = Object.assign({
+    host: process.env.REDIS_HOST || "127.0.0.1"
+  });
+  const store = new RedisStore("testStore", redisOptions);
+
+  describe("get", function () {
+    it("should retrieve an existing key", function (done) {
+
+      const key = "chuck-norris";
+      const value = "superman";
+
+      store.set(key, value)
+        .then(function (test) {
+          test.should.be.ok();
+        });
+
+      store.get(key)
+        .then(function (v) {
+          v.should.be.equal(value);
+          done();
+        });
+    });
+
+    it("should return null if key doesn't exist", function (done) {
+
+      store.get("unknownKey")
+        .then(function (v) {
+          should(v).be.null;
+          done();
+        });
+    });
+  });
+
+  describe("set", function () {
+    it("should store a value", function (done) {
+
+      const key = "key";
+      const value = "neverExpire";
+
+      store.set(key, value)
+        .then(function (test) {
+          test.should.be.ok();
+        });
+
+      store.get(key)
+        .then(function (v) {
+          v.should.be.equal(value);
+          done();
+        });
+    });
+  });
+
+  describe("setex", function () {
+    it("should store with an expiry", function (done) {
+
+      const key = "shortLivedKey";
+      const value = "expireIn10ms";
+      const ttlInSeconds = 1;
+
+      store.setex(key, value, ttlInSeconds)
+        .then(function (test) {
+          test.should.be.ok();
+        });
+
+      store.get(key)
+        .then(function (v) {
+          v.should.be.equal(value);
+        });
+
+      Bluebird.delay(ttlInSeconds * 1000)
+        .done(() => {
+          return store.get(key)
+            .then(function (v) {
+              should(v).be.null;
+              done();
+            });
+        });
+    });
+  });
+
+  describe("del", function () {
+    it("should delete an existing key", function (done) {
+
+      const key = "key";
+      const value = "neverExpire";
+
+      store.set(key, value)
+        .then(function (test) {
+          test.should.be.ok();
+        });
+
+      store.del(key)
+        .then(function (v) {
+          v.should.be.ok();
+        });
+
+      store.get(key)
+        .then(function (v) {
+          should(v).be.null;
+          done();
+        });
+    });
+
+    it("should return null deleting non-existing key", function (done) {
+      store.del("unknownKey")
+        .then(function (v) {
+          should(v).be.null;
+          done();
+        });
+    });
+  });
+});