Merge pull request #1 from cloudnode-pro/feature/tests

Implement automated unit tests

Author: williamd5

.github/workflows/test.yml

@@ -0,0 +1,35 @@
+name: Unit tests
+'on':
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+  schedule:
+    - cron: '0 6 * * 0'
+
+jobs:
+  test:
+    name: 'Node.js v${{ matrix.node }}'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node:
+          - 18
+          - 16
+    steps:
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '${{ matrix.node }}'
+      - uses: actions/checkout@v2
+      - name: 'Cache node_modules'
+        uses: actions/cache@v2
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-v${{ matrix.node }}-${{ hashFiles('**/package.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-v${{ matrix.node }}-
+      - name: Install Dependencies
+        run: npm install
+      - name: Run All Node.js Tests
+        run: npm run test

.idea/jsLibraryMappings.xml

@@ -2,9 +2,13 @@
   "name": "cldn-ratelimit",
   "version": "1.1.0",
   "description": "Simple ratelimiter for Node.js",
-  "main": "index.js",
+  "main": "lib/RateLimit.js",
+  "type": "module",
   "scripts": {
-    "test": "c8 mocha"
+    "_test": "mocha",
+    "test": "c8 npm run _test",
+    "coverage": "c8 --reporter=html npm run _test",
+    "build": "tsc"
   },
   "repository": {
     "type": "git",

package.json

@@ -53,6 +53,14 @@ export class RateLimit {
         RateLimit.#instances.set(name, this);
     }
 
+    /**
+     * Get rate limit name
+     * @readonly
+     */
+    get name(): string {
+        return this.#name;
+    }
+
     /**
      * Check the attempt state for a source ID without decrementing the remaining attempts
      * @param {string} source - Unique source identifier (e.g. username, IP, etc.)

src/RateLimit.ts

@@ -0,0 +1,132 @@
+import assert from 'assert';
+import {RateLimit} from "../lib/RateLimit.js";
+
+describe("RateLimit", () => {
+    describe("instance methods", () => {
+        it("should create a new RateLimit instance", () => {
+            assert(new RateLimit("test", 5, 1) instanceof RateLimit);
+        });
+        it("should not allow creating a new instance with the same name", () => {
+            assert.throws(() => new RateLimit("test", 5, 1));
+        });
+        it("should fetch the existing RateLimit instance", () => {
+            assert(RateLimit.get("test") instanceof RateLimit);
+        });
+        it("should decrement the remaining attempts", () => {
+            const rateLimit = RateLimit.get("test");
+            const result = rateLimit.attempt("source1");
+            assert(result.remaining === 4);
+        });
+        it("should check the remaining attempts", () => {
+            const rateLimit = RateLimit.get("test");
+            const result = rateLimit.check("source1");
+            assert(result.remaining === 4);
+        });
+        it("should prevent attempts when the limit is reached", () => {
+            const rateLimit = RateLimit.get("test");
+            rateLimit.attempt("source1"); // 3 remaining
+            rateLimit.attempt("source1"); // 2 remaining
+            rateLimit.attempt("source1"); // 1 remaining
+            rateLimit.attempt("source1"); // 0 remaining
+            const result = rateLimit.attempt("source1"); // -1 remaining
+            assert.strictEqual(result.allow, false);
+        });
+        it("should reset the remaining attempts after the timeout", async () => {
+            const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+            const rateLimit = RateLimit.get("test");
+            await sleep(1500);
+            assert.strictEqual(rateLimit.attempt("source1").allow, true);
+        });
+        it("should reset the remaining attempts", () => {
+            const rateLimit = RateLimit.get("test");
+            rateLimit.reset("source1");
+            assert.strictEqual(rateLimit.check("source1").remaining, 5);
+        });
+        it("should set the remaining attempts", () => {
+            const rateLimit = RateLimit.get("test");
+            rateLimit.setRemaining("source1", 3);
+            assert.strictEqual(rateLimit.check("source1").remaining, 3);
+        });
+        it("should reset all attempts", () => {
+            const rateLimit = RateLimit.get("test");
+            rateLimit.attempt("source2");
+            rateLimit.attempt("source3");
+            rateLimit.clear();
+            assert.strictEqual(rateLimit.check("source1").remaining, 5);
+            assert.strictEqual(rateLimit.check("source2").remaining, 5);
+            assert.strictEqual(rateLimit.check("source3").remaining, 5);
+        });
+        it("should delete the RateLimit instance", () => {
+            const rateLimit = RateLimit.get("test");
+            rateLimit.attempt("source1");
+            rateLimit.delete();
+            assert.strictEqual(RateLimit.get("test"), null);
+            assert.throws(() => rateLimit.check("source1"), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+            assert.throws(() => rateLimit.attempt("source1"), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+            assert.throws(() => rateLimit.reset("source1"), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+            assert.throws(() => rateLimit.setRemaining("source1", 3), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+            assert.throws(() => rateLimit.clear(), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+            assert.throws(() => rateLimit.delete(), {message: "Rate limit \"test\" has been deleted. Construct a new instance"});
+        });
+    });
+    describe("static methods", () => {
+        it("should create a new RateLimit instance", () => {
+            const rateLimit = RateLimit.create("test", 5, 1);
+            assert(rateLimit instanceof RateLimit);
+        });
+        it("should return the same instance if created with the same name", () => {
+            const rateLimit1 = RateLimit.create("test", 10, 1);
+            assert(rateLimit1.limit === 5);
+        });
+        it("should make a rate limit attempt", () => {
+            const result = RateLimit.attempt("test", "source1");
+            assert(result.remaining === 4);
+        });
+        it("should make an attempt with custom weight", () => {
+            const result = RateLimit.attempt("test", "source1", 2);
+            assert(result.remaining === 2);
+        });
+        it("should check the remaining attempts", () => {
+            const result = RateLimit.check("test", "source1");
+            assert(result.remaining === 2);
+        });
+        it("should prevent attempts when the limit is reached", () => {
+            RateLimit.attempt("test", "source1"); // 1 remaining
+            RateLimit.attempt("test", "source1"); // 0 remaining
+            const result = RateLimit.attempt("test", "source1"); // -1 remaining
+            assert.strictEqual(result.allow, false);
+        });
+        it("should reset the remaining attempts after the timeout", async () => {
+            const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+            await sleep(1500);
+            assert.strictEqual(RateLimit.attempt("test", "source1").allow, true);
+        });
+        it("should reset the remaining attempts", () => {
+            RateLimit.reset("test", "source1");
+            assert.strictEqual(RateLimit.check("test", "source1").remaining, 5);
+        });
+        it("should set the remaining attempts", () => {
+            RateLimit.setRemaining("test", "source1", 3);
+            assert.strictEqual(RateLimit.check("test", "source1").remaining, 3);
+        });
+        it("should reset all attempts", () => {
+            RateLimit.attempt("test", "source2");
+            RateLimit.attempt("test", "source3");
+            RateLimit.clear("test");
+            assert.strictEqual(RateLimit.check("test", "source1").remaining, 5);
+            assert.strictEqual(RateLimit.check("test", "source2").remaining, 5);
+            assert.strictEqual(RateLimit.check("test", "source3").remaining, 5);
+        });
+        it("should delete the RateLimit instance", () => {
+            RateLimit.attempt("test", "source1");
+            RateLimit.delete("test");
+            assert.strictEqual(RateLimit.get("test"), null);
+            assert.throws(() => RateLimit.check("test", "source1"), {message: "Rate limit with name \"test\" does not exist"});
+            assert.throws(() => RateLimit.attempt("test", "source1"), {message: "Rate limit with name \"test\" does not exist"});
+            assert.throws(() => RateLimit.reset("test", "source1"), {message: "Rate limit with name \"test\" does not exist"});
+            assert.throws(() => RateLimit.setRemaining("test", "source1", 3), {message: "Rate limit with name \"test\" does not exist"});
+            assert.throws(() => RateLimit.clear("test"), {message: "Rate limit with name \"test\" does not exist"});
+            assert.throws(() => RateLimit.delete("test"), {message: "Rate limit with name \"test\" does not exist"});
+        });
+    });
+});