using per-key basis queue (#5420)

* adding KeyPromiseQueue

* nit

* removing secondary object and using a tuple

* using array

* nits

* some tests

* Minor refinements

* removing old adapter

* dummy change, travis test not found

* travis test missing, dummy change

* revrting mistake

* reverting mistake

* indentation fix

* additional tests for coverage

* extending coverage

* nits

* fixing mistake

* better code

spec/RedisCacheAdapter.spec.js

@@ -45,6 +45,48 @@ describe_only(() => {
       .then(done);
   });
 
+  it('should not store value for ttl=0', done => {
+    const cache = new RedisCacheAdapter(null, 5);
+
+    cache
+      .put(KEY, VALUE, 0)
+      .then(() => cache.get(KEY))
+      .then(value => expect(value).toEqual(null))
+      .then(done);
+  });
+
+  it('should not expire when ttl=Infinity', done => {
+    const cache = new RedisCacheAdapter(null, 1);
+
+    cache
+      .put(KEY, VALUE, Infinity)
+      .then(() => cache.get(KEY))
+      .then(value => expect(value).toEqual(VALUE))
+      .then(wait.bind(null, 1))
+      .then(() => cache.get(KEY))
+      .then(value => expect(value).toEqual(VALUE))
+      .then(done);
+  });
+
+  it('should fallback to default ttl', done => {
+    const cache = new RedisCacheAdapter(null, 1);
+    let promise = Promise.resolve();
+
+    [-100, null, undefined, 'not number', true].forEach(ttl => {
+      promise = promise.then(() =>
+        cache
+          .put(KEY, VALUE, ttl)
+          .then(() => cache.get(KEY))
+          .then(value => expect(value).toEqual(VALUE))
+          .then(wait.bind(null, 2))
+          .then(() => cache.get(KEY))
+          .then(value => expect(value).toEqual(null))
+      );
+    });
+
+    promise.then(done);
+  });
+
   it('should find un-expired records', done => {
     const cache = new RedisCacheAdapter(null, 5);
 
@@ -58,3 +100,66 @@ describe_only(() => {
       .then(done);
   });
 });
+
+describe_only(() => {
+  return process.env.PARSE_SERVER_TEST_CACHE === 'redis';
+})('RedisCacheAdapter/KeyPromiseQueue', function() {
+  const KEY1 = 'key1';
+  const KEY2 = 'key2';
+  const VALUE = 'hello';
+
+  // number of chained ops on a single key
+  function getQueueCountForKey(cache, key) {
+    return cache.queue.queue[key][0];
+  }
+
+  // total number of queued keys
+  function getQueueCount(cache) {
+    return Object.keys(cache.queue.queue).length;
+  }
+
+  it('it should clear completed operations from queue', done => {
+    const cache = new RedisCacheAdapter({ ttl: NaN });
+
+    // execute a bunch of operations in sequence
+    let promise = Promise.resolve();
+    for (let index = 1; index < 100; index++) {
+      promise = promise.then(() => {
+        const key = `${index}`;
+        return cache
+          .put(key, VALUE)
+          .then(() => expect(getQueueCount(cache)).toEqual(0))
+          .then(() => cache.get(key))
+          .then(() => expect(getQueueCount(cache)).toEqual(0))
+          .then(() => cache.clear())
+          .then(() => expect(getQueueCount(cache)).toEqual(0));
+      });
+    }
+
+    // at the end the queue should be empty
+    promise.then(() => expect(getQueueCount(cache)).toEqual(0)).then(done);
+  });
+
+  it('it should count per key chained operations correctly', done => {
+    const cache = new RedisCacheAdapter({ ttl: NaN });
+
+    let key1Promise = Promise.resolve();
+    let key2Promise = Promise.resolve();
+    for (let index = 1; index < 100; index++) {
+      key1Promise = cache.put(KEY1, VALUE);
+      key2Promise = cache.put(KEY2, VALUE);
+      // per key chain should be equal to index, which is the
+      // total number of operations on that key
+      expect(getQueueCountForKey(cache, KEY1)).toEqual(index);
+      expect(getQueueCountForKey(cache, KEY2)).toEqual(index);
+      // the total keys counts should be equal to the different keys
+      // we have currently being processed.
+      expect(getQueueCount(cache)).toEqual(2);
+    }
+
+    // at the end the queue should be empty
+    Promise.all([key1Promise, key2Promise])
+      .then(() => expect(getQueueCount(cache)).toEqual(0))
+      .then(done);
+  });
+});