#10 use injectable Promise implementation in caches

Schibsted-Tech-Polska · Apr 1, 2018 · 3492f40 · 3492f40
1 parent 0d07619
commit 3492f40
Show file tree

Hide file tree

Showing 4 changed files with 88 additions and 59 deletions.
diff --git a/lib/caching/lru-cache.js b/lib/caching/lru-cache.js
@@ -1,63 +1,66 @@
 var clone = require('clone');
 
-module.exports = function(maxEntries) {
-  return new LRUCache(maxEntries);
-};
+module.exports = function(maxEntries, Promise) {
+  Promise = Promise || global.Promise;
 
-/**
- * A simple in-memory good guy cache implementation that has a cap on the maximum number of cached entries.
- * If that number is exceeded, least recently used entries are dropped.
- * @param maxEntries the maximum number of entries
- * @constructor
- */
-function LRUCache(maxEntries) {
-  this.maxEntries = maxEntries || 500;
-  this._entryOrder = [];
-  this._entryMap = {};
-}
-LRUCache.prototype = {
-  retrieve: function(key) {
-    var entry = this._entryMap[key];
-    if (entry !== undefined) {
-      this._markAsRecent(key);
-      return Promise.resolve(clone(entry));
-    } else {
-      return Promise.resolve(undefined);
-    }
-  },
-
-  store: function(key, value) {
-    value = clone(value);
-    var entry = this._entryMap[key];
-    if (entry !== undefined) {
-      this._entryMap[key] = value;
-      this._markAsRecent(key);
-    } else {
-      this._entryMap[key] = value;
-      this._entryOrder.unshift(key);
-      if (this._entryOrder.length > this.maxEntries)
-        this._discardLeastRecentlyUsed();
-    }
+  /**
+   * A simple in-memory good guy cache implementation that has a cap on the maximum number of cached entries.
+   * If that number is exceeded, least recently used entries are dropped.
+   * @param maxEntries the maximum number of entries
+   * @constructor
+   */
+  function LRUCache(maxEntries) {
+    this.maxEntries = maxEntries || 500;
+    this._entryOrder = [];
+    this._entryMap = {};
+  }
+  LRUCache.prototype = {
+    retrieve: function (key) {
+      var entry = this._entryMap[key];
+      if (entry !== undefined) {
+        this._markAsRecent(key);
+        return Promise.resolve(clone(entry));
+      } else {
+        return Promise.resolve(undefined);
+      }
+    },
 
-    return Promise.resolve();
-  },
+    store: function (key, value) {
+      value = clone(value);
+      var entry = this._entryMap[key];
+      if (entry !== undefined) {
+        this._entryMap[key] = value;
+        this._markAsRecent(key);
+      } else {
+        this._entryMap[key] = value;
+        this._entryOrder.unshift(key);
+        if (this._entryOrder.length > this.maxEntries)
+          this._discardLeastRecentlyUsed();
+      }
 
-  evict: function(key) {
-    delete this._entryMap[key];
-    return Promise.resolve();
-  },
+      return Promise.resolve();
+    },
 
-  _markAsRecent: function(key) {
-    var index = this._entryOrder.indexOf(key);
-    if (index >= 0) {
-      this._entryOrder.splice(index, 1);
-      this._entryOrder.unshift(key);
+    evict: function (key) {
+      delete this._entryMap[key];
+      return Promise.resolve();
+    },
+
+    _markAsRecent: function (key) {
+      var index = this._entryOrder.indexOf(key);
+      if (index >= 0) {
+        this._entryOrder.splice(index, 1);
+        this._entryOrder.unshift(key);
+      }
+    },
+
+    _discardLeastRecentlyUsed: function () {
+      var key = this._entryOrder.pop();
+      delete this._entryMap[key];
     }
-  },
+  };
 
-  _discardLeastRecentlyUsed: function() {
-    var key = this._entryOrder.pop();
-    delete this._entryMap[key];
-  }
+  return new LRUCache(maxEntries);
 };
 
+
diff --git a/lib/caching/null-cache.js b/lib/caching/null-cache.js
@@ -1,6 +1,7 @@
 module.exports = nullCache;
 
-function nullCache() {
+function nullCache(Promise) {
+  Promise = Promise || global.Promise;
   return {
     store: function(key, object) { return Promise.resolve(); },
     retrieve: function(key) { return Promise.resolve(undefined); },

diff --git a/lib/index.js b/lib/index.js
@@ -93,15 +93,17 @@ function goodGuyHttp(config) {
   var reqConfig = _.omit(config, OUR_CONFIGURATION_PROPERTIES);
   config = _.pick(config, OUR_CONFIGURATION_PROPERTIES);
 
+  // determine promises implementation
+  if (config.usePromise === undefined)
+    config.usePromise = global.Promise;
+  var Promise = config.usePromise;
+
   // sanitize configuration
   if (config.cache === undefined)
-    config.cache = lruCache();
+    config.cache = lruCache(undefined, Promise);
   if (config.cache === false)
-    config.cache = nullCache();
-  if (config.usePromise === undefined)
-    config.usePromise = global.Promise;
+    config.cache = nullCache(Promise);
 
-  var Promise = config.usePromise;
   var promiseUtils = require('./promise-utils')(Promise);
   var retryPromise = promiseUtils.retryPromise;
   var collapsePromises = promiseUtils.collapsePromises;

diff --git a/test/unit/lru-cache-test.js b/test/unit/lru-cache-test.js
@@ -81,4 +81,27 @@ describe('LRUCache', function(){
       assert.deepEqual(values, ['1', '2', '3', undefined, 'new']);
     }).then(done).catch(done);
   });
+
+  it('should be able to use custom Promise implementation', function(done) {
+    var spyPromise = createSpyPromise();
+    var lru = new LRUCache(2, spyPromise);
+    lru.store('hitchhiker', {answer: 42}).then(function() {
+      return lru.retrieve('hitchhiker');
+    }).then(function(object) {
+      assert.equal(spyPromise.resolveCallsCount(), 2);
+    }).then(done).catch(done);
+  });
 });
+
+function createSpyPromise() {
+  var resolveCallsCount = 0;
+  return {
+    resolve: function(value) {
+      resolveCallsCount += 1;
+      return Promise.resolve(value);
+    },
+    resolveCallsCount: function() {
+      return resolveCallsCount;
+    }
+  };
+}