Added NonSerializingCache (if you want the non-serializing version of the cache fill)

jsvennevid · jsvennevid · commit 5c72dabb8d1c · 2018-03-24T11:11:11.000+01:00
diff --git a/index.js b/index.js
@@ -1,9 +1,10 @@
 const { BaseCache } = require('./lib/base');
-const { SerializingCache } = require('./lib/serializing');
+const { SerializingCache, NonSerializingCache } = require('./lib/serializing');
 const { MemoryCache } = require('./lib/memory');
 const { OnionCache } = require('./lib/onion');
 
 exports.BaseCache = BaseCache;
 exports.SerializingCache = SerializingCache;
+exports.NonSerializingCache = NonSerializingCache;
 exports.MemoryCache = MemoryCache;
 exports.OnionCache = OnionCache;
diff --git a/lib/serializing.js b/lib/serializing.js
@@ -122,10 +122,10 @@ class SerializingCache extends BaseCache {
             return this.fill(key).then((result) => {
                 debug("Fill '%s' successful", key);
                 return this.cache.set(key, result).then(() => {
-                    debug("Storing '%s' successful");
+                    debug("Storing '%s' successful", key);
                     return result;
                 }).catch((err) => {
-                    debug("Storing '%s' failed");
+                    debug("Storing '%s' failed", key);
                     throw err;
                 });
             }).catch((err) => {
@@ -136,4 +136,45 @@ class SerializingCache extends BaseCache {
     }
 }
 
+class NonSerializingCache extends BaseCache {
+    constructor(cache, fill) {
+        super();
+
+        this.cache = cache;
+        this.fill = fill;
+    }
+
+    get(key) {
+        debug("Getting '%s'", key);
+        return this.cache.get(key).then((result) => {
+            if (result === undefined) {
+                return this.fill(key).then((result) => {
+                    debug("Fill '%s' successful", key);
+                    return this.cache.set(key, result).then(() => {
+                        debug("Storing '%s' successful", key);
+                        return result;
+                    }).catch((err) => {
+                        debug("Storing '%s' failed", key);
+                        throw err;
+                    });
+                }).catch((err) => {
+                    debug("Fill '%s' failed", key);
+                    throw err;
+                });
+            }
+
+            debug("Get '%s' successful", key);
+            return result;
+        });
+    }
+
+    del(key) {
+        debug("Deleting '%s'", key);
+        return this.cache.del(key);
+    }
+}
+
+
 exports.SerializingCache = SerializingCache;
+exports.NonSerializingCache = NonSerializingCache;
+
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "layer-cache",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "./index",
   "private": true,
   "author": "jesper@microcode.se",
diff --git a/test/serializing.js b/test/serializing.js
@@ -1,5 +1,5 @@
 const { MemoryCache } = require('..');
-const { SerializingCache } = require('..');
+const { SerializingCache, NonSerializingCache } = require('..');
 const { DelayedCache } = require('./util/delayed');
 
 const assert = require('assert');
@@ -113,3 +113,113 @@ describe("SerializingCache", function () {
         });
     });
 });
+
+describe("NonSerializingCache", function () {
+    describe('get', function () {
+        it ("should fill using callback", function () {
+            const testValue = 'value';
+            const testKey = 'key';
+
+            const memoryCache = new MemoryCache();
+            const cache = new NonSerializingCache(memoryCache, () => {
+                return new Promise((resolve) => resolve(testValue));
+            });
+
+            return cache.get(testKey).then((result) => {
+                assert(result === testValue);
+            }).then(() => {
+                return memoryCache.get(testKey).then((result) => {
+                    assert(result === testValue);
+                })
+            });
+        });
+
+        it("should only issue one read per request run", function () {
+            class TestCache extends MemoryCache {
+                constructor() {
+                    super();
+                    this.counter = 0;
+                }
+                get(key) {
+                    this.counter++;
+                    return super.get(key);
+                }
+            }
+
+            const testValue = 'value';
+            const testKey = 'key';
+
+            const rootCache = new DelayedCache(new TestCache(), { get: 10 });
+            const cache = new NonSerializingCache(rootCache, () => {
+                return new Promise((resolve) => resolve(testValue));
+            });
+
+            return Promise.all([
+                cache.get(testKey), cache.get(testKey), cache.get(testKey)
+            ]).then(() => {
+                assert.equal(rootCache.cache.counter, 3, "Cache should be read three times");
+            });
+        });
+    });
+
+    describe('set', function () {
+        it('should not be supported', function () {
+            const memoryCache = new MemoryCache();
+            const cache = new NonSerializingCache(memoryCache, () => {
+                return new Promise((resolve) => resolve("value"));
+            });
+            const testKey = 'key';
+
+            return cache.set(testKey, "dummy").then(() => {
+                throw Error("Set successful");
+            }, (err) => {});
+        });
+    });
+
+    describe('del', function () {
+        it ("should fill using callback", function () {
+            const testValue = 'value';
+            const testKey = 'key';
+
+            const memoryCache = new MemoryCache();
+            const cache = new NonSerializingCache(memoryCache, () => {
+                return new Promise((resolve) => resolve(testValue));
+            });
+
+            return cache.get(testKey).then((result) => {
+                assert(result === testValue);
+            }).then(() => {
+                return memoryCache.get(testKey).then((result) => {
+                    assert(result === testValue);
+                })
+            });
+        });
+
+        it("should only issue one delete per request run", function () {
+            class TestCache extends MemoryCache {
+                constructor() {
+                    super();
+                    this.counter = 0;
+                }
+                del(key) {
+                    this.counter++;
+                    return super.del(key);
+                }
+            }
+
+            const testValue = 'value';
+            const testKey = 'key';
+
+            const rootCache = new DelayedCache(new TestCache(), { get: 10 });
+            const cache = new NonSerializingCache(rootCache, () => {
+                return new Promise((resolve) => resolve(testValue));
+            });
+
+            return Promise.all([
+                cache.del(testKey), cache.del(testKey), cache.del(testKey)
+            ]).then(() => {
+                assert.equal(rootCache.cache.counter, 3, "Cache entry should be deleted three times");
+            });
+        });
+    });
+});

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "layer-cache",`
`3`		`- "version": "1.1.0",`
	`3`	`+ "version": "1.2.0",`
`4`	`4`	`"main": "./index",`
`5`	`5`	`"private": true,`
`6`	`6`	`"author": "[email protected]",`