Merge pull request #352 from animir/test-zero-points

animir · web-flow · commit c37a85df5a96 · 2026-03-10T20:47:59.000+01:00
Test all limiters don't allow to consume if points value is zero
diff --git a/test/RateLimiterDrizzle/Postgres/RateLimiterDrizzleNonAtomicPostgres.test.js b/test/RateLimiterDrizzle/Postgres/RateLimiterDrizzleNonAtomicPostgres.test.js
@@ -50,6 +50,23 @@ describe('RateLimiterDrizzleNonAtomic Postgres with fixed window', function Rate
     }
   });
 
+  it('does not allow to consume if points is zero', async () => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterDrizzleNonAtomic({
+      storeClient: db,
+      schema: rateLimiterFlexible,
+      points: 0,
+      duration: 5,
+    });
+
+    try {
+      await rateLimiter.consume(testKey, 1);
+      expect.fail('should have thrown');
+    } catch (rejRes) {
+      expect(rejRes.msBeforeNext >= 0).to.equal(true);
+    }
+  });
+
   it('execute evenly over duration', async () => {
     const testKey = 'consumeEvenly';
     const rateLimiter = new RateLimiterDrizzleNonAtomic({
diff --git a/test/RateLimiterDrizzle/Postgres/RateLimiterDrizzlePostgres.test.js b/test/RateLimiterDrizzle/Postgres/RateLimiterDrizzlePostgres.test.js
@@ -50,6 +50,23 @@ describe('RateLimiterDrizzle Postgres with fixed window', function RateLimiterDr
     }
   });
 
+  it('does not allow to consume if points is zero', async () => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterDrizzle({
+      storeClient: db,
+      schema: rateLimiterFlexible,
+      points: 0,
+      duration: 5,
+    });
+
+    try {
+      await rateLimiter.consume(testKey, 1);
+      expect.fail('should have thrown');
+    } catch (rejRes) {
+      expect(rejRes.msBeforeNext >= 0).to.equal(true);
+    }
+  });
+
   it('execute evenly over duration', async () => {
     const testKey = 'consumeEvenly';
     const rateLimiter = new RateLimiterDrizzle({
diff --git a/test/RateLimiterDynamo.test.js b/test/RateLimiterDynamo.test.js
@@ -160,6 +160,27 @@ describe('RateLimiterDynamo with fixed window', function RateLimiterDynamoTest()
         });
     });
 
+    it('does not allow to consume if points is zero', (done) => {
+        const testKey = 'consumezero';
+
+        const rateLimiter = new RateLimiterDynamo({
+            storeClient: dynamoClient,
+            points: 0,
+            duration: 5
+        },
+        () => {
+            rateLimiter.consume(testKey, 1)
+                .then(() => {})
+                .catch((rejRes) => {
+                    expect(rejRes.msBeforeNext >= 0).to.equal(true);
+                    done();
+                })
+                .catch((err) => {
+                    done(err);
+                });
+        });
+    });
+
     it('blocks key for block duration when consumed more than points', (done) => {
         const testKey = 'block';
         
diff --git a/test/RateLimiterEtcd.test.js b/test/RateLimiterEtcd.test.js
@@ -101,6 +101,25 @@ describe('RateLimiterEtcd', function RateLimiterEtcdTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const rateLimiter = new RateLimiterEtcd({
+      storeClient: etcdClient,
+      points: 0,
+      duration: 5,
+    });
+
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('execute evenly over duration', (done) => {
     const rateLimiter = new RateLimiterEtcd({
       storeClient: etcdClient,
diff --git a/test/RateLimiterEtcdNonAtomic.test.js b/test/RateLimiterEtcdNonAtomic.test.js
@@ -75,6 +75,25 @@ describe('RateLimiterEtcdNonAtomic', function RateLimiterEtcdNonAtomicTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const rateLimiter = new RateLimiterEtcdNonAtomic({
+      storeClient: etcdClient,
+      points: 0,
+      duration: 5,
+    });
+
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('execute evenly over duration', (done) => {
     const rateLimiter = new RateLimiterEtcdNonAtomic({
       storeClient: etcdClient,
diff --git a/test/RateLimiterMemcache.test.js b/test/RateLimiterMemcache.test.js
@@ -57,6 +57,25 @@ describe('RateLimiterMemcache', function RateLimiterMemcacheTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterMemcache({
+      storeClient: memcacheMockClient,
+      points: 0,
+      duration: 5,
+    });
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('execute evenly over duration', (done) => {
     const testKey = 'consumeEvenly';
     const rateLimiter = new RateLimiterMemcache({
diff --git a/test/RateLimiterMemory.test.js b/test/RateLimiterMemory.test.js
@@ -414,4 +414,18 @@ describe('RateLimiterMemory with fixed window', function RateLimiterMemoryTest()
         done(err);
       });
   });
+
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    const rateLimiterMemory = new RateLimiterMemory({ points: 0, duration: 5 });
+    rateLimiterMemory.consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
 });
diff --git a/test/RateLimiterMongo.test.js b/test/RateLimiterMongo.test.js
@@ -100,6 +100,30 @@ describe('RateLimiterMongo with fixed window', function RateLimiterMongoTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    sinon.stub(mongoCollection, 'findOneAndUpdate').callsFake(() => {
+      const res = {
+        value: {
+          points: 1,
+          expire: 5000,
+        },
+      };
+      return Promise.resolve(res);
+    });
+
+    const rateLimiter = new RateLimiterMongo({ storeClient: mongoClient, points: 0, duration: 5 });
+    rateLimiter.consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('makes penalty', (done) => {
     const testKey = 'penalty1';
     sinon.stub(mongoCollection, 'findOneAndUpdate').callsFake(() => {
diff --git a/test/RateLimiterMySQL.test.js b/test/RateLimiterMySQL.test.js
@@ -156,6 +156,35 @@ describe('RateLimiterMySQL with fixed window', function RateLimiterMySQLTest() {
     });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+
+    const rateLimiter = new RateLimiterMySQL({
+      storeClient: mysqlClient, storeType: 'connection', points: 0, duration: 5,
+    }, () => {
+      mysqlClientStub.restore();
+      sinon.stub(mysqlClient, 'query').callsFake((q, data, cb) => {
+        const res = [
+          { points: 1, expire: 5000 },
+        ];
+        if (Array.isArray(data)) {
+          cb(null, res);
+        } else {
+          data(null);
+        }
+      });
+      rateLimiter.consume(testKey, 1)
+        .then(() => {})
+        .catch((rejRes) => {
+          expect(rejRes.msBeforeNext >= 0).to.equal(true);
+          done();
+        })
+        .catch((err) => {
+          done(err);
+        });
+    });
+  });
+
   it('blocks key for block duration when consumed more than points', (done) => {
     const testKey = 'block';
 
diff --git a/test/RateLimiterPostgres.test.js b/test/RateLimiterPostgres.test.js
@@ -103,6 +103,28 @@ describe('RateLimiterPostgres with fixed window', function RateLimiterPostgresTe
     });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+
+    const rateLimiter = new RateLimiterPostgres({
+      storeClient: pgClient, storeType: 'client', points: 0, duration: 5,
+    }, () => {
+      pgClientStub.restore();
+      pgClientStub = sinon.stub(pgClient, 'query').resolves({
+        rows: [{ points: 1, expire: 5000 }],
+      });
+      rateLimiter.consume(testKey, 1)
+        .then(() => {})
+        .catch((rejRes) => {
+          expect(rejRes.msBeforeNext >= 0).to.equal(true);
+          done();
+        })
+        .catch((err) => {
+          done(err);
+        });
+    });
+  });
+
   it('blocks key for block duration when consumed more than points', (done) => {
     const testKey = 'block';
 
diff --git a/test/RateLimiterPrisma/Postgres/RateLimiterPrismaPostgres.test.js b/test/RateLimiterPrisma/Postgres/RateLimiterPrismaPostgres.test.js
@@ -54,6 +54,22 @@ describe('RateLimiterPrisma Postgres with fixed window', function RateLimiterPri
     }
   });
 
+  it('does not allow to consume if points is zero', async () => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterPrisma({
+      storeClient: prisma,
+      points: 0,
+      duration: 5,
+    });
+
+    try {
+      await rateLimiter.consume(testKey, 1);
+      expect.fail('should have thrown');
+    } catch (rejRes) {
+      expect(rejRes.msBeforeNext >= 0).to.equal(true);
+    }
+  });
+
   it('execute evenly over duration', async () => {
     const testKey = 'consumeEvenly';
     const rateLimiter = new RateLimiterPrisma({
diff --git a/test/RateLimiterRedis.ioredis.test.js b/test/RateLimiterRedis.ioredis.test.js
@@ -59,6 +59,25 @@ describe('RateLimiterRedis with fixed window', function RateLimiterRedisTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterRedis({
+      storeClient: redisMockClient,
+      points: 0,
+      duration: 5,
+    });
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   describe('when customIncrTtlLuaScript is provided', () => {
     it('rejected when consume more than maximum points and multiply delay', (done) => {
       const testKey = 'consume2';
diff --git a/test/RateLimiterRedis.redis.test.js b/test/RateLimiterRedis.redis.test.js
@@ -58,6 +58,26 @@ describe('RateLimiterRedis with fixed window', function RateLimiterRedisTest() {
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterRedis({
+      storeClient: redisMockClient,
+      points: 0,
+      duration: 5,
+      useRedisPackage: true,
+    });
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   describe('when resetting maximum points', () => {
     it('consume 2 points', (done) => {
       const testKey = 'consume1';
diff --git a/test/RateLimiterRedisNonAtomic.ioredis.test.js b/test/RateLimiterRedisNonAtomic.ioredis.test.js
@@ -57,6 +57,25 @@ describe('RateLimiterRedisNonAtomic with fixed window', function RateLimiterRedi
       });
   });
 
+  it('does not allow to consume if points is zero', (done) => {
+    const testKey = 'consumezero';
+    const rateLimiter = new RateLimiterRedisNonAtomic({
+      storeClient: redisMockClient,
+      points: 0,
+      duration: 5,
+    });
+    rateLimiter
+      .consume(testKey, 1)
+      .then(() => {})
+      .catch((rejRes) => {
+        expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        done();
+      })
+      .catch((err) => {
+        done(err);
+      });
+  });
+
   it('sets expire when existing key has no ttl', (done) => {
     const testKey = 'no-ttl';
     const rateLimiter = new RateLimiterRedisNonAtomic({
diff --git a/test/RateLimiterSQLite.test.js b/test/RateLimiterSQLite.test.js
@@ -61,6 +61,23 @@ function testRateLimiterSQLite(library, createDb, clientName = null) {
         expect(res2.consumedPoints).to.equal(2);
         expect(res2.remainingPoints).to.equal(3);
       });
+
+      it("does not allow to consume if points is zero", async () => {
+        const zeroLimiter = new RateLimiterSQLite({
+          storeClient: db,
+          storeType: library,
+          tableName: "rate_limiter_test",
+          points: 0,
+          duration: 5,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        try {
+          await zeroLimiter.consume("consumezero", 1);
+          expect.fail("should have thrown");
+        } catch (rejRes) {
+          expect(rejRes.msBeforeNext >= 0).to.equal(true);
+        }
+      });
     });
 
     describe("block functionality", () => {
diff --git a/test/RateLimiterValkey.iovalkey.test.js b/test/RateLimiterValkey.iovalkey.test.js
diff --git a/test/RateLimiterValkeyGlide.test.js b/test/RateLimiterValkeyGlide.test.js
