updated tests and tweaked sliding window to pass all tests

Author: jondeweydev

src/rateLimiters/slidingWindowCounter.ts

@@ -91,14 +91,14 @@ class SlidingWindowCounter implements RateLimiter {
                 fixedWindowStart: timestamp,
             };
 
-            if (tokens > this.capacity) {
+            if (tokens <= this.capacity) {
                 await this.client.setex(uuid, keyExpiry, JSON.stringify(newUserWindow));
-                // tokens property represents how much capacity remains
-                return { success: false, tokens: this.capacity };
+                return { success: true, tokens: this.capacity - newUserWindow.currentTokens };
             }
 
             await this.client.setex(uuid, keyExpiry, JSON.stringify(newUserWindow));
-            return { success: true, tokens: this.capacity - newUserWindow.currentTokens };
+            // tokens property represents how much capacity remains
+            return { success: false, tokens: this.capacity };
         }
 
         // if the cache is populated
@@ -112,45 +112,44 @@ class SlidingWindowCounter implements RateLimiter {
         };
 
         // if request time is in a new window
-        if (timestamp > window.fixedWindowStart + this.windowSize + 1) {
+        if (timestamp >= window.fixedWindowStart + this.windowSize + 1) {
             updatedUserWindow.previousTokens = updatedUserWindow.currentTokens;
             updatedUserWindow.currentTokens = 0;
-            updatedUserWindow.fixedWindowStart = window.fixedWindowStart + this.windowSize;
+            updatedUserWindow.fixedWindowStart = window.fixedWindowStart + this.windowSize + 1;
         }
 
         // assigned to avoid TS error, this var will never be used as 0
         // var is declared here so that below can be inside a conditional for efficiency's sake
         let rollingWindowProportion = 0;
+        let previousRollingTokens = 0;
 
         if (updatedUserWindow.previousTokens) {
-            // subtract window size by current time less fixed window's start
-            // current time less fixed window start is the amount that rolling window is in current window
-            // to get amount that rolling window is in previous window, we subtract this difference by window size
-            // then we divide this amount by window size to get the proportion of rolling window in previous window
-            // ex. 60000 - (1million+5 - 1million) = 59995 / 60000 = 0.9999
+            // proportion of rolling window present in previous window
             rollingWindowProportion =
                 (this.windowSize - (timestamp - updatedUserWindow.fixedWindowStart)) /
                 this.windowSize;
 
             // remove unecessary decimals, 0.xx is enough
             rollingWindowProportion -= rollingWindowProportion % 0.01;
+
+            // # of tokens present in rolling & previous window
+            previousRollingTokens = Math.floor(
+                updatedUserWindow.previousTokens * rollingWindowProportion
+            );
         }
 
-        // the sliding window counter formula
-        // ex. tokens(1) + currentTokens(2) + previousTokens(4) * RWP(.75) = 6 < capacity(10)
-        // adjusts formula if previousTokens is null
-        const rollingWindowAllowal = updatedUserWindow.previousTokens
-            ? tokens +
-                  updatedUserWindow.currentTokens +
-                  updatedUserWindow.previousTokens * rollingWindowProportion <=
-              this.capacity
-            : tokens + updatedUserWindow.currentTokens <= this.capacity;
+        // # of tokens present in rolling and/or current window
+        // if previous tokens is null, previousRollingTokens will be 0
+        const rollingTokens = updatedUserWindow.currentTokens + previousRollingTokens;
 
         // if request is allowed
-        if (rollingWindowAllowal) {
+        if (tokens + rollingTokens <= this.capacity) {
             updatedUserWindow.currentTokens += tokens;
             await this.client.setex(uuid, keyExpiry, JSON.stringify(updatedUserWindow));
-            return { success: true, tokens: this.capacity - updatedUserWindow.currentTokens };
+            return {
+                success: true,
+                tokens: this.capacity - (updatedUserWindow.currentTokens + previousRollingTokens),
+            };
         }
 
         // if request is blocked

test/rateLimiters/slidingWindowCounter.test.ts

@@ -91,6 +91,7 @@ describe('Test TokenBucket Rate Limiter', () => {
                 await setTokenCountInClient(client, user4, 10, null, timestamp);
                 // tokens returned in processRequest is equal to the capacity
                 // still available in the fixed window
+
                 expect(
                     (await limiter.processRequest(user4, timestamp + WINDOW_SIZE + 1, 1)).tokens
                 ).toBe(0); // here, we expect the rolling window to only allow 1 token, b/c
@@ -199,8 +200,8 @@ describe('Test TokenBucket Rate Limiter', () => {
                     (await limiter.processRequest(user2, timestamp + WINDOW_SIZE, 5)).tokens
                 ).toBe(CAPACITY - initRequest);
 
-                // expect current tokens in the window to still be 0
-                expect((await getWindowFromClient(client, user2)).currentTokens).toBe(0);
+                // expect current tokens in the window to still be 6
+                expect((await getWindowFromClient(client, user2)).currentTokens).toBe(6);
             });
 
             // 3 rolling window tests with different proportions (.25, .5, .75)
@@ -276,7 +277,7 @@ describe('Test TokenBucket Rate Limiter', () => {
             // currentTokens (in current fixed window): 0
             // previousTokens (in previous fixed window): 8
             const count = await getWindowFromClient(client, user4);
-            expect(count.currentTokens).toBe(4);
+            expect(count.currentTokens).toBe(0);
             expect(count.previousTokens).toBe(initRequest);
         });
     });
@@ -321,20 +322,19 @@ describe('Test TokenBucket Rate Limiter', () => {
         });
 
         test('fixed window and current/previous tokens update as expected', async () => {
-            await setTokenCountInClient(client, user1, 0, null, timestamp);
-            // fills first window with 4 tokens
+            // fills first window with 5 tokens
             await limiter.processRequest(user1, timestamp, 5);
-            // fills second window with 5 tokens
+            // fills second window with 4 tokens
             expect(
                 await (
                     await limiter.processRequest(user1, timestamp + WINDOW_SIZE + 1, 4)
                 ).tokens
-            ).toBe(6);
+            ).toBe(2);
             // currentTokens (in current fixed window): 0
             // previousTokens (in previous fixed window): 8
-            const count = await getWindowFromClient(client, user4);
+            const count = await getWindowFromClient(client, user1);
             // ensures that fixed window is updated when a request goes over
-            expect(count.fixedWindowStart).toBe(timestamp + WINDOW_SIZE);
+            expect(count.fixedWindowStart).toBe(timestamp + WINDOW_SIZE + 1);
             // ensures that previous tokens property updates on fixed window change
             expect(count.previousTokens).toBe(5);
             // ensures that current tokens only represents tokens from current window requests
@@ -348,10 +348,11 @@ describe('Test TokenBucket Rate Limiter', () => {
 
             await newLimiter.processRequest(user1, timestamp, 8);
 
-            // expect that a new window is entered, leaving 9 tokens available after a 1 token request
+            // expect that a new window is entered, leaving 2 tokens available after both requests
+            // 8 * .99 -> 7 (floored) + 1 = 8
             expect(
                 (await newLimiter.processRequest(user1, timestamp + newWindowSize + 1, 1)).tokens
-            ).toBe(9);
+            ).toBe(2);
         });
 
         test('sliding window allows custom capacities', async () => {