Merge pull request #3 from pearlshare/master

code improvements

Author: pasupulaphani

lib/redis_cache.js

@@ -4,66 +4,61 @@ const RedisStore = require("./redis_store");
 
 const debug = require("debug")("simpleRedisCache");
 
-function set (store, key, value, ttlInSeconds) {
-  if (!store || ttlInSeconds === 0) return Promise.resolve(value);
-
-  if (ttlInSeconds) {
-    return store.setex(key, value, ttlInSeconds);
-  } else {
-    return store.set(key, value);
-  }
-}
-
 function RedisCache (name, redisOptions, poolOptions) {
-  let store;
+
+  this.name = name;
+  this.redisOptions = redisOptions;
+  this.poolOptions = poolOptions;
 
   try {
-    store = new RedisStore(name, redisOptions, poolOptions);
+    this.store = new RedisStore(name, redisOptions, poolOptions);
+    debug("Success in connecting to Redis", redisOptions);
   } catch (e) {
-    debug("Redis cache connection failed", e);
-    return;
+    debug("Failed in connecting to Redis", redisOptions);
   }
+}
 
-  return {
-    wrap: (key, promise, ttlInSeconds) => {
+RedisCache.prototype.set = function (key, value, ttlInSeconds) {
+  if (!this.store || ttlInSeconds === 0) return Promise.resolve(value);
 
-      if (!store || ttlInSeconds === 0) {
-        return Promise.resolve(promise);
-      }
+  return this.store.set(key, value, ttlInSeconds);
+};
 
-      return store.get(key)
-        .then(value => {
-          if (!value) {
-            debug("MISS", {key: key});
-            return Promise.resolve(promise)
-              .then(value => set(store, key, value, ttlInSeconds).then(() => value));
-          } else {
-            debug("HIT", {key: key});
-            return Promise.resolve(value);
-          }
-        });
-    },
+RedisCache.prototype.get = function (key) {
+  if (!this.store) return;
 
-    set: (key, value, ttlInSeconds) => set(store, key, value, ttlInSeconds),
+  return this.store.get(key);
+};
 
-    get: (key) => {
-      if (!store) return;
+RedisCache.prototype.keys = function () {
+  if (!this.store) return;
 
-      return store.get(key);
-    },
+  return this.store.keys();
+};
 
-    keys: () => {
-      if (!store) return;
+RedisCache.prototype.deleteAll = function () {
+  if (!this.store) return;
 
-      return store.keys();
-    },
+  return this.store.deleteAll();
+};
 
-    deleteAll: () => {
-      if (!store) return;
+RedisCache.prototype.wrap = function (key, promise, ttlInSeconds) {
 
-      return store.deleteAll();
-    }
-  };
-}
+  if (!this.store || ttlInSeconds === 0) {
+    return Promise.resolve(promise);
+  }
+
+  return this.store.get(key)
+    .then(value => {
+      if (!value) {
+        debug("MISS", {key: key});
+        return Promise.resolve(promise)
+          .then(value => this.set(key, value, ttlInSeconds).then(() => value));
+      } else {
+        debug("HIT", {key: key});
+        return Promise.resolve(value);
+      }
+    });
+};
 
 module.exports = RedisCache;

lib/redis_store.js

@@ -1,5 +1,4 @@
 const RedisPool = require("./redis_pool");
-const bind = require("./util/bind");
 
 const debug = require("debug")("simpleRedisStore");
 
@@ -21,22 +20,27 @@ function RedisStore (name, redisOptions, poolOptions) {
   if (!poolOptions) {
     poolOptions = {};
   }
+
   poolOptions = Object.assign({
     acquireTimeoutMillis: 50
   }, poolOptions);
 
   const pool = new RedisPool(name, redisOptions, poolOptions);
   debug("Redis store created.", pool.status());
 
-  this.getName = bind(pool.getName, pool);
-  this.getRedisDB = bind(pool.getDB, pool);
-  this.getPoolStatus = bind(pool.status, pool);
+  this.getName = pool.getName.bind(pool);
+  this.getRedisDB = pool.getDB.bind(pool);
+  this.getPoolStatus = pool.status.bind(pool);
 
   this.get = (key) => wrapFunc(pool, (conn) => conn.getAsync(key));
 
-  this.set = (key, value) => wrapFunc(pool, (conn) => conn.setAsync(key, value));
-
-  this.setex = (key, value, ttlInSeconds) => wrapFunc(pool, (conn) => conn.setexAsync(key, ttlInSeconds, value));
+  this.set = (key, value, ttlInSeconds) => {
+    if (ttlInSeconds) {
+      return wrapFunc(pool, (conn) => conn.setexAsync(key, ttlInSeconds, value));
+    } else {
+      return wrapFunc(pool, (conn) => conn.setAsync(key, value));
+    }
+  };
 
   this.del = (key) => wrapFunc(pool, (conn) => conn.delAsync(key));
 

lib/util/bind.js

@@ -1,7 +1,7 @@
 const should = require("should");
 const RedisCache = require("../lib/redis_cache");
 
-describe("cache", function () {
+describe("redisCache", function () {
 
   const redisOptions = Object.assign({
     host: process.env.REDIS_HOST || "127.0.0.1"
@@ -93,9 +93,7 @@ describe("cache", function () {
         .then(function (v) {
           v.should.be.equal(value);
         })
-        .then(function () {
-          return cache.get(key);
-        })
+        .then(() => cache.get(key))
         .then(function (v) {
           v.should.be.equal(value);
           done();
@@ -108,9 +106,7 @@ describe("cache", function () {
         .then(function (v) {
           v.should.be.ok();
         })
-        .then(function () {
-          return cache.wrap(key);
-        })
+        .then(() => cache.wrap(key))
         .then(function (v) {
           v.should.be.equal(value);
           done();
@@ -177,11 +173,12 @@ describe("cache", function () {
         .then(function (v) {
           v.should.be.ok();
         })
-        .then(cache.keys)
-        .then(function (keys) {
+        .then(() => cache.keys())
+        .then(keys => {
           keys.should.be.empty();
           done();
-        });
+        })
+        .catch(e => console.log(e));
     });
   });
 });

test/redis_cache.js

@@ -16,11 +16,10 @@ describe("redisStore", function () {
       const value = "superman";
 
       store.set(key, value)
-        .then(function (test) {
+        .then(test => {
           test.should.be.ok();
-        });
-
-      store.get(key)
+        })
+        .then(() => store.get(key))
         .then(function (v) {
           v.should.be.equal(value);
           done();
@@ -46,29 +45,25 @@ describe("redisStore", function () {
       store.set(key, value)
         .then(function (test) {
           test.should.be.ok();
-        });
-
-      store.get(key)
+        })
+        .then(() => store.get(key))
         .then(function (v) {
           v.should.be.equal(value);
           done();
         });
     });
-  });
 
-  describe("setex", function () {
-    it("should store with an expiry", function (done) {
+    it("should store with an expiry if ttl set", function (done) {
 
       const key = "shortLivedKey";
-      const value = "expireIn10ms";
+      const value = "expireIn1s";
       const ttlInSeconds = 1;
 
-      store.setex(key, value, ttlInSeconds)
+      store.set(key, value, ttlInSeconds)
         .then(function (test) {
           test.should.be.ok();
-        });
-
-      store.get(key)
+        })
+        .then(() => store.get(key))
         .then(function (v) {
           v.should.be.equal(value);
         });
@@ -93,14 +88,12 @@ describe("redisStore", function () {
       store.set(key, value)
         .then(function (test) {
           test.should.be.ok();
-        });
-
-      store.del(key)
+        })
+        .then(() => store.del(key))
         .then(function (v) {
           v.should.be.ok();
-        });
-
-      store.get(key)
+        })
+        .then(() => store.get(key))
         .then(function (v) {
           should(v).be.null;
           done();
@@ -126,9 +119,8 @@ describe("redisStore", function () {
       store.set(key, value)
         .then(function (test) {
           test.should.be.ok();
-        });
-
-      store.expire(key, ttlInSeconds)
+        })
+        .then(() => store.expire(key, ttlInSeconds))
         .then(function (v) {
           v.should.be.ok();
         });
@@ -159,12 +151,11 @@ describe("redisStore", function () {
       const value = "make it expire";
       const ttlInSeconds = 10;
 
-      store.setex(key, value, ttlInSeconds)
+      store.set(key, value, ttlInSeconds)
         .then(function (test) {
           test.should.be.ok();
-        });
-
-      store.ttlInSeconds(key)
+        })
+        .then(() => store.ttlInSeconds(key))
         .then(function (v) {
 
           // it should be same as the time elapsed is very vvery small