nosible 0.2.13 → 0.2.16

package/src/utils/rateLimiters.test.ts

@@ -0,0 +1,652 @@
+import {describe, it, expect} from "bun:test";
+import {createLimiters} from "./rateLimiters";
+import type {LimitsResponse} from "../api/schemas";
+
+describe("rateLimiters", () => {
+  describe("createLimiters", () => {
+    it("should create limiters from limits response", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 3000,
+            limited: false,
+            remaining: 2925,
+            period_start: "2026-02-02T14:02:57.687557",
+            period_end: "2026-03-02T14:02:57.687557",
+          },
+          {
+            name: "slow_minute",
+            query_type: "slow",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "slow_four_week",
+            query_type: "slow",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 300,
+            limited: false,
+            remaining: 296,
+            period_start: "2026-02-02T14:02:57.687557",
+            period_end: "2026-03-02T14:02:57.687557",
+          },
+          {
+            name: "visit_minute",
+            query_type: "visit",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "visit_four_week",
+            query_type: "visit",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 300,
+            limited: false,
+            remaining: 298,
+            period_start: "2026-02-02T14:02:57.687557",
+            period_end: "2026-03-02T14:02:57.687557",
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters).toBeDefined();
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle partial limits data with fallback values", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 100,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters).toBeDefined();
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should use remaining values when available", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 100,
+            limited: false,
+            remaining: 50,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 5000,
+            limited: false,
+            remaining: 4800,
+            period_start: "2026-02-02T14:02:57.687557",
+            period_end: "2026-03-02T14:02:57.687557",
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle empty limits array with fallback values", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters).toBeDefined();
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle empty limits array with unlimited limiters", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+
+      // Limiters should be unlimited (no reservoir configuration)
+      // This is indicated by the absence of reservoir constraints
+    });
+
+    it("should create separate limiters for each query type", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 360,
+            limited: false,
+            remaining: 360,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "slow_minute",
+            query_type: "slow",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "visit_minute",
+            query_type: "visit",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.fast).not.toBe(limiters.bulk);
+      expect(limiters.bulk).not.toBe(limiters.scrapeUrl);
+      expect(limiters.scrapeUrl).not.toBe(limiters.fast);
+    });
+
+    it("should handle rate-limited scenarios", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: true,
+            remaining: 0,
+            period_start: "2026-02-04T10:00:00.000000",
+            period_end: "2026-02-04T10:01:00.000000",
+          },
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 3000,
+            limited: false,
+            remaining: 2500,
+            period_start: "2026-02-02T14:02:57.687557",
+            period_end: "2026-03-02T14:02:57.687557",
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle all three query types with four_week limits", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 360,
+            limited: false,
+            remaining: 350,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 3000000,
+            limited: false,
+            remaining: 2999000,
+            period_start: "2026-01-05T00:00:00.000000",
+            period_end: "2026-02-02T00:00:00.000000",
+          },
+          {
+            name: "slow_minute",
+            query_type: "slow",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 360,
+            limited: false,
+            remaining: 360,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "slow_four_week",
+            query_type: "slow",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 300000,
+            limited: false,
+            remaining: 299500,
+            period_start: "2026-01-05T00:00:00.000000",
+            period_end: "2026-02-02T00:00:00.000000",
+          },
+          {
+            name: "visit_minute",
+            query_type: "visit",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 360,
+            limited: false,
+            remaining: 360,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "visit_four_week",
+            query_type: "visit",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 300000,
+            limited: false,
+            remaining: 299800,
+            period_start: "2026-01-05T00:00:00.000000",
+            period_end: "2026-02-02T00:00:00.000000",
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle API keys with only minute limits (no four_week limits)", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 115,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "slow_minute",
+            query_type: "slow",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 118,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "visit_minute",
+            query_type: "visit",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 120,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle mixed scenarios - some query types with four_week, some without", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 360,
+            limited: false,
+            remaining: 360,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200,
+            duration_string: "four_week",
+            limit: 3000000,
+            limited: false,
+            remaining: 2999000,
+            period_start: "2026-01-05T00:00:00.000000",
+            period_end: "2026-02-02T00:00:00.000000",
+          },
+          {
+            name: "slow_minute",
+            query_type: "slow",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "visit_minute",
+            query_type: "visit",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 60,
+            limited: false,
+            remaining: 60,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should work with only minute limits for a single query type", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 10,
+            limited: false,
+            remaining: 5,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle dynamic durations like 5-minute limits", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_5min",
+            query_type: "fast",
+            duration_seconds: 300, // 5 minutes
+            duration_string: "five_minute",
+            limit: 500,
+            limited: false,
+            remaining: 450,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "slow_5min",
+            query_type: "slow",
+            duration_seconds: 300,
+            duration_string: "five_minute",
+            limit: 100,
+            limited: false,
+            remaining: 95,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should handle multiple custom duration limits for a single query type", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 120,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_5min",
+            query_type: "fast",
+            duration_seconds: 300,
+            duration_string: "five_minute",
+            limit: 500,
+            limited: false,
+            remaining: 500,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_hour",
+            query_type: "fast",
+            duration_seconds: 3600,
+            duration_string: "hour",
+            limit: 5000,
+            limited: false,
+            remaining: 5000,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_day",
+            query_type: "fast",
+            duration_seconds: 86400,
+            duration_string: "day",
+            limit: 100000,
+            limited: false,
+            remaining: 100000,
+            period_start: "2026-02-04T00:00:00.000000",
+            period_end: "2026-02-05T00:00:00.000000",
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.fast).toBeDefined();
+      expect(limiters.scrapeUrl).toBeDefined();
+      expect(limiters.bulk).toBeDefined();
+    });
+
+    it("should sort and chain limiters by duration (shortest first)", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_four_week",
+            query_type: "fast",
+            duration_seconds: 2419200, // Listed first but longest
+            duration_string: "four_week",
+            limit: 3000000,
+            limited: false,
+            remaining: 3000000,
+            period_start: "2026-01-05T00:00:00.000000",
+            period_end: "2026-02-02T00:00:00.000000",
+          },
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60, // Should be sorted first
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 120,
+            period_start: null,
+            period_end: null,
+          },
+          {
+            name: "fast_hour",
+            query_type: "fast",
+            duration_seconds: 3600, // Should be in middle
+            duration_string: "hour",
+            limit: 5000,
+            limited: false,
+            remaining: 5000,
+            period_start: null,
+            period_end: null,
+          },
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      expect(limiters.fast).toBeDefined();
+    });
+
+    it("should create unlimited limiters for query types without limits", () => {
+      const mockLimitsResponse: LimitsResponse = {
+        api_key_id: "test-api-key-id",
+        subscription_id: "test-subscription-id",
+        limits: [
+          {
+            name: "fast_minute",
+            query_type: "fast",
+            duration_seconds: 60,
+            duration_string: "minute",
+            limit: 120,
+            limited: false,
+            remaining: 120,
+            period_start: null,
+            period_end: null,
+          },
+          // No slow/visit limits defined
+        ],
+      };
+
+      const limiters = createLimiters(mockLimitsResponse);
+
+      // Fast should have limits
+      expect(limiters.fast).toBeDefined();
+
+      // Slow and visit should be unlimited (no limits defined)
+      expect(limiters.bulk).toBeDefined();
+      expect(limiters.scrapeUrl).toBeDefined();
+    });
+  });
+});