nosible 0.1.5

package/src/utils/llm.ts

@@ -0,0 +1,244 @@
+import OpenAI from "openai";
+
+/**
+ * Default LLM model used for sentiment analysis and query expansion.
+ * Uses Google's Gemini 2.0 Flash model via OpenAI-compatible API.
+ */
+const defaultModel = "google/gemini-2.0-flash-001";
+
+/**
+ * Analyzes the sentiment of a given text using an LLM.
+ * 
+ * Returns a numeric score between -1.0 (very negative) and 1.0 (very positive).
+ * The function uses a structured prompt to ensure consistent numeric output.
+ * 
+ * @param options - Configuration options for sentiment analysis
+ * @param options.text - The text to analyze for sentiment. Must not be empty or whitespace.
+ * @param options.model - The LLM model to use. Defaults to "google/gemini-2.0-flash-001".
+ * @param options.llmClient - OpenAI client instance for making API calls. Must be provided.
+ * 
+ * @returns Promise<number> - A sentiment score between -1.0 and 1.0
+ * 
+ * @throws {Error} When llmClient is not provided
+ * @throws {Error} When text is empty or contains only whitespace
+ * @throws {Error} When the LLM response is not a valid float
+ * @throws {Error} When the sentiment score is outside the valid range [-1.0, 1.0]
+ * 
+ * @example
+ * ```typescript
+ * import OpenAI from "openai";
+ * import { getSentiment } from "./llm";
+ * 
+ * const client = new OpenAI({ apiKey: "your-api-key" });
+ * const score = await getSentiment({
+ *   text: "I love this product!",
+ *   llmClient: client
+ * });
+ * console.log(score); // Output: 0.8 (approximately)
+ * ```
+ */
+export const getSentiment = async ({
+  text,
+  model = defaultModel,
+  llmClient,
+}: {
+  /** The text to analyze for sentiment */
+  text: string;
+  /** The LLM model to use for analysis */
+  model?: string;
+  /** OpenAI client instance for API calls */
+  llmClient: OpenAI | undefined;
+}): Promise<number> => {
+  if (!llmClient) {
+    throw new Error(
+      "A OpenAI client instance must be provided as 'llmClient'."
+    );
+  }
+
+  if (!text || text.trim() === "") {
+    throw new Error("Text must not be empty or whitespace.");
+  }
+
+  const prompt = `
+    # TASK DESCRIPTION
+    On a scale from -1.0 (very negative) to 1.0 (very positive),
+    please rate the sentiment of the following text and return _only_ the numeric score:
+    ${text.trim()}
+
+    # RESPONSE FORMAT
+
+    The response must be a float in [-1.0, 1.0]. No other text must be returned.
+  `;
+
+  try {
+    const completion = await llmClient.chat.completions.create({
+      model: model,
+      messages: [{role: "user", content: prompt.trim()}],
+      temperature: 0.7,
+    });
+    const raw = completion.choices[0]?.message?.content as string;
+
+    const score = parseFloat(raw);
+    if (Number.isNaN(score)) {
+      throw new Error(
+        `Sentiment response is not a float: ${JSON.stringify(raw)}`
+      );
+    }
+    if (score < -1.0 || score > 1.0) {
+      throw new Error(`Sentiment ${score} outside valid range [-1.0, 1.0]`);
+    }
+
+    return score;
+  } catch (error) {
+    throw error;
+  }
+};
+
+/**
+ * Generates semantic query expansions to improve search recall.
+ * 
+ * Creates 10 semantically equivalent but lexically different questions
+ * that maintain the same intent while using different wording and entities.
+ * This helps search engines find more relevant documents through query variation.
+ * 
+ * The generated expansions follow specific guidelines:
+ * - Include specific named entities (people, places, organizations)
+ * - Are highly targeted and semantically unambiguous
+ * - Use between 10-15 words per question
+ * - Leverage semantic and contextual expansion techniques
+ * 
+ * @param options - Configuration options for query expansion
+ * @param options.question - The original search question to expand. Must not be empty or whitespace.
+ * @param options.model - The LLM model to use. Defaults to "google/gemini-2.0-flash-001".
+ * @param options.llmClient - OpenAI client instance for making API calls. Must be provided.
+ * 
+ * @returns Promise<string[]> - An array of 10 expanded query strings
+ * 
+ * @throws {Error} When llmClient is not provided
+ * @throws {Error} When question is empty or contains only whitespace
+ * @throws {Error} When the LLM response is not valid JSON
+ * @throws {Error} When the response doesn't contain exactly 10 string items
+ * 
+ * @example
+ * ```typescript
+ * import OpenAI from "openai";
+ * import { generateExpansions } from "./llm";
+ * 
+ * const client = new OpenAI({ apiKey: "your-api-key" });
+ * const expansions = await generateExpansions({
+ *   question: "best restaurants in New York",
+ *   llmClient: client
+ * });
+ * console.log(expansions);
+ * // Output: [
+ * //   "top dining establishments Manhattan NYC",
+ * //   "fine eating places New York City",
+ * //   "recommended food venues NYC boroughs",
+ * //   ...
+ * // ]
+ * ```
+ */
+export const generateExpansions = async ({
+  question,
+  model = defaultModel,
+  llmClient,
+}: {
+  /** The original search question to expand */
+  question: string;
+  /** The LLM model to use for expansion */
+  model?: string;
+  /** OpenAI client instance for API calls */
+  llmClient: OpenAI | undefined;
+}): Promise<string[]> => {
+  if (!llmClient) {
+    throw new Error(
+      "A OpenAI client instance must be provided as 'llmClient'."
+    );
+  }
+
+  if (!question || question.trim() === "") {
+    throw new Error("Question must not be empty or whitespace.");
+  }
+
+  const prompt = `
+            # TASK DESCRIPTION
+
+
+            Given a search question you must generate a list of 10 similar questions that have the same exact
+            semantic meaning but are contextually and lexically different to improve search recall.
+
+
+            ## Question
+
+            Here is the question you must generate expansions for:
+
+            Question: ${question.trim()}
+
+            # RESPONSE FORMAT
+
+            Your response must be a JSON object structured as follows: a list of ten strings. Each string must
+            be a grammatically correct question that expands on the original question to improve recall.
+
+            [
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string,
+                string
+            ]
+
+            # EXPANSION GUIDELINES
+
+            1. **Use specific named entities** - To improve the quality of your search results you must mention
+               specific named entities (people, locations, organizations, products, places) in expansions.
+            2. **Expansions must be highly targeted** - To improve the quality of search results each expansion
+               must be semantically unambiguous. Questions must be use between ten and fifteen words.
+            3. **Expansions must improve recall** - When expanding the question leverage semantic and contextual
+               expansion to maximize the ability of the search engine to find semantically relevant documents:
+               - Semantic Example: Swap "climate change" with "global warming" or "environmental change".
+               - Contextual Example: Swap "diabetes treatment" with "insulin therapy" or "blood sugar management".
+  `;
+
+  try {
+    const completion = await llmClient.chat.completions.create({
+      model: model,
+      messages: [{role: "user", content: prompt.trim()}],
+      temperature: 0.7,
+    });
+
+    let raw = (completion.choices[0]?.message?.content as string) ?? "";
+    let toParse = raw.trim();
+
+    if (toParse.startsWith("```")) {
+      toParse = toParse.replace(/^```+/, "").trim();
+      if (toParse.toLowerCase().startsWith("json")) {
+        toParse = toParse.slice(4).trim();
+      }
+      toParse = toParse.replace(/```+$/, "").trim();
+    }
+
+    let expansions: unknown;
+    try {
+      expansions = JSON.parse(toParse);
+    } catch (decodeErr) {
+      throw new Error(`OpenRouter response was not valid JSON: '${toParse}'`);
+    }
+
+    if (
+      !Array.isArray(expansions) ||
+      expansions.length !== 10 ||
+      !expansions.every((q) => typeof q === "string")
+    ) {
+      throw new Error("Invalid response: 'choices' missing or empty");
+    }
+    console.debug("Expansions: ", expansions);
+    return expansions as string[];
+  } catch (error) {
+    throw error;
+  }
+};

package/src/utils/userPlan.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, test } from "bun:test";
+import { getUserPlan, getLimiters, type Plan } from "./userPlan";
+import Bottleneck from "bottleneck";
+
+describe("getUserPlan", () => {
+  test("returns correct plan for test API key", () => {
+    const plan = getUserPlan("test|some-api-key");
+    expect(plan.key).toBe("test");
+    expect(plan.name).toBe("Test");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(300);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(300);
+    expect(plan.rateLimits.fast.minute).toBe(60);
+    expect(plan.rateLimits.fast.month).toBe(3000);
+  });
+
+  test("returns correct plan for basic API key", () => {
+    const plan = getUserPlan("basic|some-api-key");
+    expect(plan.key).toBe("basic");
+    expect(plan.name).toBe("Basic");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(1400);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(1400);
+    expect(plan.rateLimits.fast.minute).toBe(60);
+    expect(plan.rateLimits.fast.month).toBe(14000);
+  });
+
+  test("returns correct plan for pro API key", () => {
+    const plan = getUserPlan("pro|some-api-key");
+    expect(plan.key).toBe("pro");
+    expect(plan.name).toBe("Pro");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(6700);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(6700);
+    expect(plan.rateLimits.fast.minute).toBe(60);
+    expect(plan.rateLimits.fast.month).toBe(67000);
+  });
+
+  test("returns correct plan for pro+ API key", () => {
+    const plan = getUserPlan("pro+|some-api-key");
+    expect(plan.key).toBe("pro+");
+    expect(plan.name).toBe("Pro+");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(32000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(32000);
+    expect(plan.rateLimits.fast.minute).toBe(60);
+    expect(plan.rateLimits.fast.month).toBe(320000);
+  });
+
+  test("returns correct plan for business API key", () => {
+    const plan = getUserPlan("bus|some-api-key");
+    expect(plan.key).toBe("bus");
+    expect(plan.name).toBe("Business");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(200000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(200000);
+    expect(plan.rateLimits.fast.minute).toBe(60);
+    expect(plan.rateLimits.fast.month).toBe(2000000);
+  });
+
+  test("returns correct plan for business+ API key", () => {
+    const plan = getUserPlan("bus+|some-api-key");
+    expect(plan.key).toBe("bus+");
+    expect(plan.name).toBe("Business+");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(500000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(500000);
+    expect(plan.rateLimits.fast.minute).toBe(120);
+    expect(plan.rateLimits.fast.month).toBe(5000000);
+  });
+
+  test("returns correct plan for enterprise API key", () => {
+    const plan = getUserPlan("ent|some-api-key");
+    expect(plan.key).toBe("ent");
+    expect(plan.name).toBe("Enterprise");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(1500000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(1500000);
+    expect(plan.rateLimits.fast.minute).toBe(360);
+    expect(plan.rateLimits.fast.month).toBe(15000000);
+  });
+
+  test("returns correct plan for production API key", () => {
+    const plan = getUserPlan("prod|some-api-key");
+    expect(plan.key).toBe("prod");
+    expect(plan.name).toBe("Production");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(1500000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(1500000);
+    expect(plan.rateLimits.fast.minute).toBe(360);
+    expect(plan.rateLimits.fast.month).toBe(15000000);
+  });
+
+  test("returns correct plan for chat API key", () => {
+    const plan = getUserPlan("chat|some-api-key");
+    expect(plan.key).toBe("chat");
+    expect(plan.name).toBe("Chat");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(1500000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(1500000);
+    expect(plan.rateLimits.fast.minute).toBe(360);
+    expect(plan.rateLimits.fast.month).toBe(15000000);
+  });
+
+  test("returns correct plan for self API key", () => {
+    const plan = getUserPlan("self|some-api-key");
+    expect(plan.key).toBe("self");
+    expect(plan.name).toBe("Self");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(6000);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(1500000);
+    expect(plan.rateLimits.bulk.minute).toBe(6000);
+    expect(plan.rateLimits.bulk.month).toBe(1500000);
+    expect(plan.rateLimits.fast.minute).toBe(36000);
+    expect(plan.rateLimits.fast.month).toBe(15000000);
+  });
+
+  test("returns correct plan for consumer API key", () => {
+    const plan = getUserPlan("cons|some-api-key");
+    expect(plan.key).toBe("cons");
+    expect(plan.name).toBe("Consumer");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(3000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(3000);
+    expect(plan.rateLimits.fast.minute).toBe(120);
+    expect(plan.rateLimits.fast.month).toBe(30000);
+  });
+
+  test("returns correct plan for startup API key", () => {
+    const plan = getUserPlan("stup|some-api-key");
+    expect(plan.key).toBe("stup");
+    expect(plan.name).toBe("Startup");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(30000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(30000);
+    expect(plan.rateLimits.fast.minute).toBe(360);
+    expect(plan.rateLimits.fast.month).toBe(300000);
+  });
+
+  test("returns correct plan for business network API key", () => {
+    const plan = getUserPlan("busn|some-api-key");
+    expect(plan.key).toBe("busn");
+    expect(plan.name).toBe("Business Network");
+    expect(plan.rateLimits.scrapeUrl.minute).toBe(60);
+    expect(plan.rateLimits.scrapeUrl.month).toBe(300000);
+    expect(plan.rateLimits.bulk.minute).toBe(60);
+    expect(plan.rateLimits.bulk.month).toBe(300000);
+    expect(plan.rateLimits.fast.minute).toBe(360);
+    expect(plan.rateLimits.fast.month).toBe(3000000);
+  });
+
+  test("handles API key with additional pipe characters", () => {
+    const plan = getUserPlan("pro|key|with|multiple|pipes");
+    expect(plan.key).toBe("pro");
+    expect(plan.name).toBe("Pro");
+  });
+
+  test("throws error for invalid API key", () => {
+    expect(() => getUserPlan("invalid|some-api-key")).toThrow("Invalid API key");
+  });
+
+  test("throws error for API key with unknown plan", () => {
+    expect(() => getUserPlan("unknown|some-api-key")).toThrow("Invalid API key");
+  });
+
+  test("throws error for empty API key", () => {
+    expect(() => getUserPlan("")).toThrow("Invalid API key");
+  });
+
+  test("throws error for API key with only pipe", () => {
+    expect(() => getUserPlan("|some-api-key")).toThrow("Invalid API key");
+  });
+});
+
+describe("getLimiters", () => {
+  test("returns Bottleneck limiters for test plan", () => {
+    const limiters = getLimiters("test|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("returns Bottleneck limiters for pro plan", () => {
+    const limiters = getLimiters("pro|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("returns Bottleneck limiters for enterprise plan", () => {
+    const limiters = getLimiters("ent|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("returns Bottleneck limiters for self plan", () => {
+    const limiters = getLimiters("self|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("limiters have correct reservoir settings for basic plan", () => {
+    const limiters = getLimiters("basic|some-api-key");
+    
+    // Test plan limits: scrapeUrl: {minute: 60, month: 1400}
+    const scrapeUrlLimiter = limiters.scrapeUrl;
+    expect(scrapeUrlLimiter).toBeInstanceOf(Bottleneck);
+    
+    // Test plan limits: bulk: {minute: 60, month: 1400}
+    const bulkLimiter = limiters.bulk;
+    expect(bulkLimiter).toBeInstanceOf(Bottleneck);
+    
+    // Test plan limits: fast: {minute: 60, month: 14000}
+    const fastLimiter = limiters.fast;
+    expect(fastLimiter).toBeInstanceOf(Bottleneck);
+  });
+
+  test("limiters have different settings for business+ plan", () => {
+    const limiters = getLimiters("bus+|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("limiters have different settings for enterprise plan", () => {
+    const limiters = getLimiters("ent|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("limiters have different settings for self plan", () => {
+    const limiters = getLimiters("self|some-api-key");
+    
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+
+  test("throws error for invalid plan key", () => {
+    expect(() => getLimiters("invalid|some-api-key")).toThrow("Invalid API key");
+  });
+
+  test("returns separate limiter instances", () => {
+    const limiters1 = getLimiters("test|some-api-key");
+    const limiters2 = getLimiters("test|some-api-key");
+    
+    expect(limiters1.scrapeUrl).not.toBe(limiters2.scrapeUrl);
+    expect(limiters1.bulk).not.toBe(limiters2.bulk);
+    expect(limiters1.fast).not.toBe(limiters2.fast);
+  });
+
+  test("limiters are chained (minute + month)", () => {
+    const limiters = getLimiters("test|some-api-key");
+    
+    // All limiters should be chained limiters (minute + month)
+    expect(limiters.scrapeUrl).toBeInstanceOf(Bottleneck);
+    expect(limiters.bulk).toBeInstanceOf(Bottleneck);
+    expect(limiters.fast).toBeInstanceOf(Bottleneck);
+  });
+});
+
+describe("Plan type validation", () => {
+  test("all plans have required properties", () => {
+    const plans: Plan[] = [
+      { key: "test", name: "Test", rateLimits: { scrapeUrl: { minute: 60, month: 300 }, bulk: { minute: 60, month: 300 }, fast: { minute: 60, month: 3000 } } },
+      { key: "basic", name: "Basic", rateLimits: { scrapeUrl: { minute: 60, month: 1400 }, bulk: { minute: 60, month: 1400 }, fast: { minute: 60, month: 14000 } } },
+      { key: "pro", name: "Pro", rateLimits: { scrapeUrl: { minute: 60, month: 6700 }, bulk: { minute: 60, month: 6700 }, fast: { minute: 60, month: 67000 } } },
+    ];
+
+    plans.forEach(plan => {
+      expect(plan).toHaveProperty("key");
+      expect(plan).toHaveProperty("name");
+      expect(plan).toHaveProperty("rateLimits");
+      expect(plan.rateLimits).toHaveProperty("scrapeUrl");
+      expect(plan.rateLimits).toHaveProperty("bulk");
+      expect(plan.rateLimits).toHaveProperty("fast");
+      
+      expect(plan.rateLimits.scrapeUrl).toHaveProperty("minute");
+      expect(plan.rateLimits.scrapeUrl).toHaveProperty("month");
+      expect(plan.rateLimits.bulk).toHaveProperty("minute");
+      expect(plan.rateLimits.bulk).toHaveProperty("month");
+      expect(plan.rateLimits.fast).toHaveProperty("minute");
+      expect(plan.rateLimits.fast).toHaveProperty("month");
+      
+      expect(typeof plan.rateLimits.scrapeUrl.minute).toBe("number");
+      expect(typeof plan.rateLimits.scrapeUrl.month).toBe("number");
+      expect(typeof plan.rateLimits.bulk.minute).toBe("number");
+      expect(typeof plan.rateLimits.bulk.month).toBe("number");
+      expect(typeof plan.rateLimits.fast.minute).toBe("number");
+      expect(typeof plan.rateLimits.fast.month).toBe("number");
+    });
+  });
+
+  test("plan limits are progressive", () => {
+    const testPlan = getUserPlan("test|key");
+    const basicPlan = getUserPlan("basic|key");
+    const proPlan = getUserPlan("pro|key");
+    const busPlan = getUserPlan("bus|key");
+
+    // Monthly limits should increase with plan tier
+    expect(testPlan.rateLimits.scrapeUrl.month).toBeLessThan(basicPlan.rateLimits.scrapeUrl.month);
+    expect(basicPlan.rateLimits.scrapeUrl.month).toBeLessThan(proPlan.rateLimits.scrapeUrl.month);
+    expect(proPlan.rateLimits.scrapeUrl.month).toBeLessThan(busPlan.rateLimits.scrapeUrl.month);
+
+    expect(testPlan.rateLimits.bulk.month).toBeLessThan(basicPlan.rateLimits.bulk.month);
+    expect(basicPlan.rateLimits.bulk.month).toBeLessThan(proPlan.rateLimits.bulk.month);
+    expect(proPlan.rateLimits.bulk.month).toBeLessThan(busPlan.rateLimits.bulk.month);
+
+    expect(testPlan.rateLimits.fast.month).toBeLessThan(basicPlan.rateLimits.fast.month);
+    expect(basicPlan.rateLimits.fast.month).toBeLessThan(proPlan.rateLimits.fast.month);
+    expect(proPlan.rateLimits.fast.month).toBeLessThan(busPlan.rateLimits.fast.month);
+  });
+});