#113 fix queue delay with exec evenly flag (#359)

* #113 fix queue delay when points consumed evenly over duration

Author: animir

lib/RateLimiterMemory.js

@@ -35,6 +35,8 @@ class RateLimiterMemory extends RateLimiterAbstract {
         if (delay < this.execEvenlyMinDelayMs) {
           delay = res.consumedPoints * this.execEvenlyMinDelayMs;
         }
+        // Adjust msBeforeNext to reflect time already waited before resolving
+        res.msBeforeNext = Math.max(res.msBeforeNext - delay, 0);
 
         setTimeout(resolve, delay, res);
       } else {

lib/RateLimiterStoreAbstract.js

@@ -85,6 +85,9 @@ module.exports = class RateLimiterStoreAbstract extends RateLimiterInsuredAbstra
         delay = res.consumedPoints * this.execEvenlyMinDelayMs;
       }
 
+      // Adjust msBeforeNext to reflect time already waited before resolving
+      res.msBeforeNext = Math.max(res.msBeforeNext - delay, 0);
+
       setTimeout(resolve, delay, res);
     } else {
       resolve(res);

test/RateLimiterMemory.test.js

@@ -86,6 +86,40 @@ describe('RateLimiterMemory with fixed window', function RateLimiterMemoryTest()
       });
   });
 
+  it('updates msBeforeNext after execEvenly delay', (done) => {
+    const testKey = 'consumeEvenlyMsBeforeNext';
+    const rateLimiterMemory = new RateLimiterMemory({
+      points: 2, duration: 5, execEvenly: true, execEvenlyMinDelayMs: 500,
+    });
+
+    rateLimiterMemory.consume(testKey)
+      .then((resFirst) => {
+        const initialMsBeforeNext = resFirst.msBeforeNext;
+        const expectedDelay = Math.ceil(initialMsBeforeNext / 2);
+        const timeFirstConsume = Date.now();
+        rateLimiterMemory.consume(testKey)
+          .then((resSecond) => {
+            const diff = Date.now() - timeFirstConsume;
+
+            // Real delay should be close to calculated one from formula
+            expect(diff).to.be.greaterThan(expectedDelay - 100);
+            expect(diff).to.be.lessThan(expectedDelay + 100);
+
+            // msBeforeNext should be reduced approximately by that delay
+            expect(resSecond.msBeforeNext >= 0).to.equal(true);
+            expect(resSecond.msBeforeNext)
+              .to.be.closeTo(initialMsBeforeNext - expectedDelay, 100);
+            done();
+          })
+          .catch((err) => {
+            done(err);
+          });
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('makes penalty', (done) => {
     const testKey = 'penalty1';
     const rateLimiterMemory = new RateLimiterMemory({ points: 3, duration: 5 });

test/RateLimiterQueue.test.js

@@ -232,4 +232,32 @@ describe('RateLimiterQueue with FIFO queue', function RateLimiterQueueTest() {
           });
       });
   });
+
+  it('works correctly with underlying execEvenly limiter (no extra wait from stale msBeforeNext)', (done) => {
+    const rlMemory = new RateLimiterMemory({
+      points: 2,
+      duration: 1,
+      execEvenly: true,
+      execEvenlyMinDelayMs: 100,
+    });
+    const rlQueue = new RateLimiterQueue(rlMemory);
+    const startTime = Date.now();
+
+    rlQueue.removeTokens(1)
+      .then(() => {
+
+        rlQueue.removeTokens(1)
+          .then(() => {
+            const diff = Date.now() - startTime;
+            expect(diff).to.be.closeTo(500, 100);
+            done();
+          })
+          .catch((err) => {
+            done(err);
+          });
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
 });