prepare 5.6.1 release

caching_store_wrapper.js

@@ -77,6 +77,10 @@ function CachingStoreWrapper(underlyingStore, ttl) {
     }
 
     underlyingStore.getAllInternal(kind, function(items) {
+      if (items === null || items === undefined) {
+        cb(items);
+        return;
+      }
       var filteredItems = {};
       Object.keys(items).forEach(function(key) {
         var item = items[key];
@@ -125,7 +129,7 @@ function CachingStoreWrapper(underlyingStore, ttl) {
   };
 
   this.close = function() {
-    cache.close();
+    cache && cache.close();
     underlyingStore.close();
   };
 

test/caching_store_wrapper-test.js

@@ -6,6 +6,9 @@ function MockCore() {
     data: { features: {} },
     inited: false,
     initQueriedCount: 0,
+    getAllError: false,
+    upsertError: null,
+    closed: false,
 
     initInternal: function(newData, cb) { 
       c.data = newData;
@@ -17,10 +20,14 @@ function MockCore() {
     },
 
     getAllInternal: function(kind, cb) {
-      cb(c.data[kind.namespace]);
+      cb(c.getAllError ? null : c.data[kind.namespace]);
     },
 
     upsertInternal: function(kind, item, cb) {
+      if (c.upsertError) {
+        cb(c.upsertError, null);
+        return;
+      }
       const oldItem = c.data[kind.namespace][item.key];
       if (oldItem && oldItem.version >= item.version) {
         cb(null, oldItem);
@@ -35,6 +42,10 @@ function MockCore() {
       cb(c.inited);
     },
 
+    close: function() {
+      c.closed = true;
+    },
+
     forceSet: function(kind, item) {
       c.data[kind.namespace][item.key] =  item;
     },
@@ -194,6 +205,15 @@ describe('CachingStoreWrapper', function() {
     });
   });
 
+  runCachedAndUncachedTests('all() error condition', function(done, wrapper, core, isCached) {
+    core.getAllError = true;
+
+    wrapper.all(features, function(items) {
+      expect(items).toBe(null);
+      done();
+    });
+  });
+
   runCachedTestOnly('cached all() uses values from init()', function(done, wrapper, core) {
     const flag1 = { key: 'flag1', version: 1 };
     const flag2 = { key: 'flag2', version: 1 };
@@ -263,6 +283,34 @@ describe('CachingStoreWrapper', function() {
     });
   });
 
+  runCachedAndUncachedTests('upsert() - error', function(done, wrapper, core, isCached) {
+    const flagv1 = { key: 'flag', version: 1 };
+    const flagv2 = { key: 'flag', version: 2 };
+
+    wrapper.upsert(features, flagv1, function() {
+      expect(core.data[features.namespace][flagv1.key]).toEqual(flagv1);
+
+      core.upsertError = new Error('sorry');
+
+      wrapper.upsert(features, flagv2, function() {
+        expect(core.data[features.namespace][flagv1.key]).toEqual(flagv1);
+
+        // if we have a cache, verify that the old item is still cached by writing a different value
+        // to the underlying data - get() should still return the cached item
+        if (isCached) {
+          const flagv3 = { key: 'flag', version: 3 };
+          core.forceSet(features, flagv3);
+          wrapper.get(features, flagv1.key, function(item) {
+            expect(item).toEqual(flagv1);  
+            done();
+          });
+        } else {
+          done();
+        }
+      });
+    });
+  });
+
   runCachedTestOnly('cached upsert() - unsuccessful', function(done, wrapper, core) {
     const flagv1 = { key: 'flag', version: 1 };
     const flagv2 = { key: 'flag', version: 2 };
@@ -383,4 +431,12 @@ describe('CachingStoreWrapper', function() {
       });
     });
   });
+
+  describe('close()', function() {
+    runCachedAndUncachedTests('closes underlying store', function(done, wrapper, core) {
+      wrapper.close();
+      expect(core.closed).toBe(true);
+      done();
+    });
+  });
 });