trying to configure redis-mock to connect and read/write for the tests

Author: evanmcneely

src/rateLimiters/tokenBucket.ts

@@ -34,14 +34,10 @@ class TokenBucket implements RateLimiter {
         timestamp: number,
         tokens = 1
     ): Promise<RateLimiterResponse> {
-        // set an expiry for key-pairs in redis to 24 hours
-        const bucketExpiry = 86400000;
-
         // attempt to get the value for the uuid from the redis cache
-        const bucketJSON = await this.client.get('uuid');
-
+        const bucketJSON = await this.client.get(uuid);
         // if the response is null, we need to create bucket for the user
-        if (bucketJSON === null) {
+        if (bucketJSON === undefined || bucketJSON === null) {
             if (tokens > this.capacity) {
                 // reject the request, not enough tokens in bucket
                 return {
@@ -53,7 +49,7 @@ class TokenBucket implements RateLimiter {
                 tokens: this.capacity - tokens,
                 timestamp,
             };
-            await this.client.setEx(uuid, bucketExpiry, JSON.stringify(newUserBucket));
+            await this.client.set(uuid, JSON.stringify(newUserBucket));
             return {
                 success: true,
                 tokens: newUserBucket.tokens,
@@ -78,7 +74,7 @@ class TokenBucket implements RateLimiter {
             tokens: bucket.tokens - tokens,
             timestamp,
         };
-        await this.client.setEx(uuid, bucketExpiry, JSON.stringify(updatedUserBucket));
+        await this.client.set(uuid, JSON.stringify(updatedUserBucket));
         return {
             success: true,
             tokens: updatedUserBucket.tokens,

test/rateLimiters/tokenBucket.test.ts

@@ -18,7 +18,9 @@ async function getBucketFromClient(
     redisClient: RedisClientType,
     uuid: string
 ): Promise<RedisBucket> {
-    return redisClient.get(uuid).then((res) => JSON.parse(res || '{}'));
+    const res = await redisClient.get(uuid);
+    if (res === undefined || res === null) return { tokens: -1, timestamp: -1 };
+    return JSON.parse(res!);
 }
 
 async function setTokenCountInClient(
@@ -31,7 +33,7 @@ async function setTokenCountInClient(
     await redisClient.set(uuid, JSON.stringify(value));
 }
 
-xdescribe('Test TokenBucket Rate Limiter', () => {
+describe('Test TokenBucket Rate Limiter', () => {
     beforeEach(async () => {
         // Initialize a new token bucket before each test
         // create a mock user
@@ -50,7 +52,7 @@ xdescribe('Test TokenBucket Rate Limiter', () => {
                     CAPACITY - withdraw5
                 );
                 const tokenCountFull = await getBucketFromClient(client, user1);
-                expect(tokenCountFull).toBe(CAPACITY - withdraw5);
+                expect(tokenCountFull.tokens).toBe(CAPACITY - withdraw5);
             });
 
             test('bucket is partially full and request has leftover tokens', async () => {
@@ -69,7 +71,7 @@ xdescribe('Test TokenBucket Rate Limiter', () => {
                     ).tokens
                 ).toBe(CAPACITY - (initial + partialWithdraw));
                 const tokenCountPartial = await getBucketFromClient(client, user2);
-                expect(tokenCountPartial).toBe(CAPACITY - (initial + partialWithdraw));
+                expect(tokenCountPartial.tokens).toBe(CAPACITY - (initial + partialWithdraw));
             });
 
             // Bucket partially full and no leftover tokens after reqeust
@@ -78,15 +80,15 @@ xdescribe('Test TokenBucket Rate Limiter', () => {
                 await setTokenCountInClient(client, user2, initial, timestamp);
                 expect((await limiter.processRequest(user2, timestamp, initial)).tokens).toBe(0);
                 const tokenCountPartialToEmpty = await getBucketFromClient(client, user2);
-                expect(tokenCountPartialToEmpty).toBe(0);
+                expect(tokenCountPartialToEmpty.tokens).toBe(0);
             });
 
             // Bucket initially empty but enough time elapsed to paritally fill bucket since last request
             test('bucket is initially empty but enough time has elapsed to partially fill the bucket', async () => {
                 await setTokenCountInClient(client, user4, 0, timestamp);
                 expect((await limiter.processRequest(user4, timestamp + 6000, 4)).tokens).toBe(2);
                 const count = await getBucketFromClient(client, user4);
-                expect(count).toBe(2);
+                expect(count.tokens).toBe(2);
             });
         });