nosible 0.1.5

package/src/search/result.test.ts

@@ -0,0 +1,423 @@
+import {describe, it, expect, beforeEach, beforeAll, vi} from "bun:test";
+import {Result} from "./result";
+import {type FlattenResult} from "./result.types";
+import {NosibleClient} from "../client";
+import {ResultSet} from "./resultSet";
+import {WebPageData} from "../scrape/webPageData";
+import type {SimilarUserSearchParamsType} from "./search";
+import {
+  createMockScrapeResponse,
+  createMockSnippet,
+} from "../scrape/webPageData.test";
+import {
+  mockSemantics,
+  mockSearchResponse,
+  mockResult,
+  mockSearchQuery,
+  createMockClient,
+} from "../test-utils/mocks";
+
+// Mock scrape response for WebPageData testing
+const mockScrapeResponse = createMockScrapeResponse({
+  snippet1: createMockSnippet("snippet1", null, null, "Sample snippet content"),
+});
+
+const mockClient = createMockClient() as unknown as NosibleClient;
+
+// Re-export for backward compatibility with other test files
+export {
+  mockSemantics,
+  mockSearchResponse,
+  mockResult,
+  mockSearchQuery,
+  createMockClient,
+};
+
+describe("Result", () => {
+  let realClient: NosibleClient;
+  let mockResultInstance: Result;
+  let realResult: Result;
+  let originalUrlHash: string;
+
+  beforeAll(async () => {
+    // Setup real client for integration tests
+    realClient = new NosibleClient();
+
+    // Execute a fast search to get a real result
+    const searchResultSet = await realClient.fastSearch({
+      question: "artificial intelligence machine learning",
+      nResults: 10,
+    });
+
+    // Get the first result from the search
+    if (searchResultSet.results.length > 0) {
+      const firstResult = searchResultSet.results[0];
+      if (!firstResult) {
+        throw new Error("Expected first result to be defined");
+      }
+
+      realResult = firstResult;
+    } else {
+      throw new Error("No search results found. Cannot proceed with test.");
+    }
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockResultInstance = new Result({
+      client: mockClient,
+      result: mockResult,
+    });
+  });
+
+  describe("constructor", () => {
+    it("should create a Result instance with all required properties", () => {
+      expect(mockResultInstance).toBeInstanceOf(Result);
+      expect(mockResultInstance.url_hash).toBe("abc123");
+      expect(mockResultInstance.url).toBe("https://example.com/article");
+      expect(mockResultInstance.netloc).toBe("example.com");
+      expect(mockResultInstance.published).toBe("2023-01-15");
+      expect(mockResultInstance.visited).toBe("2023-01-16");
+      expect(mockResultInstance.language).toBe("en");
+      expect(mockResultInstance.author).toBe("John Doe");
+      expect(mockResultInstance.title).toBe("Test Article Title");
+      expect(mockResultInstance.description).toBe(
+        "This is a test article description"
+      );
+      expect(mockResultInstance.content).toBe(
+        "This is the full content of the test article. It contains multiple sentences and provides comprehensive information about the topic being discussed."
+      );
+      expect(mockResultInstance.best_chunk).toBe(
+        "This is the most relevant chunk of content from the article."
+      );
+      expect(mockResultInstance.semantics).toEqual(mockSemantics);
+      expect(mockResultInstance.client).toBe(mockClient);
+    });
+
+    it("should handle null values for optional fields", () => {
+      const resultWithNulls = new Result({
+        client: mockClient,
+        result: {
+          ...mockResult,
+          brand_safety: null,
+          continent: null,
+          region: null,
+          country: null,
+          sector: null,
+          industry_group: null,
+          industry: null,
+          sub_industry: null,
+          iab_tier_1: null,
+          iab_tier_2: null,
+          iab_tier_3: null,
+          iab_tier_4: null,
+        },
+      });
+
+      expect(resultWithNulls.brand_safety).toBeNull();
+      expect(resultWithNulls.continent).toBeNull();
+      expect(resultWithNulls.region).toBeNull();
+      expect(resultWithNulls.country).toBeNull();
+      expect(resultWithNulls.sector).toBeNull();
+      expect(resultWithNulls.industry_group).toBeNull();
+      expect(resultWithNulls.industry).toBeNull();
+      expect(resultWithNulls.sub_industry).toBeNull();
+      expect(resultWithNulls.iab_tier_1).toBeNull();
+      expect(resultWithNulls.iab_tier_2).toBeNull();
+      expect(resultWithNulls.iab_tier_3).toBeNull();
+      expect(resultWithNulls.iab_tier_4).toBeNull();
+    });
+  });
+
+  describe("getSentiment", () => {
+    it("should throw error when client has no llmClient", async () => {
+      const clientWithoutLLM = {} as NosibleClient;
+      const resultWithoutLLM = new Result({
+        client: clientWithoutLLM,
+        result: mockResult,
+      });
+
+      await expect(resultWithoutLLM.getSentiment()).rejects.toThrow(
+        "A Nosible client instance must be provided with a OpenRouter API key."
+      );
+    });
+
+    it("should call getSentiment with correct parameters when llmClient exists", async () => {
+      expect(mockResultInstance.getSentiment).toBeDefined();
+      expect(typeof mockResultInstance.getSentiment).toBe("function");
+
+      // Mock the LLM response for this test
+      (mockClient.llmClient?.chat.completions.create as any).mockResolvedValue({
+        choices: [{message: {content: "0.5"}}],
+      });
+
+      // Verify that the method can be called without errors
+      await expect(
+        mockResultInstance.getSentiment("google/gemini-2.0-flash-001")
+      ).resolves.toBeDefined();
+    });
+  });
+
+  describe("getSimilar", () => {
+    it("should call client.fastSearch with correct parameters", async () => {
+      const mockResultSet = new ResultSet([]);
+      (mockClient.fastSearch as any).mockResolvedValue(mockResultSet);
+
+      const searchParams: SimilarUserSearchParamsType = {
+        nResults: 10,
+        minSimilarity: 0.7,
+      };
+
+      const similarResults = await mockResultInstance.getSimilar(searchParams);
+
+      expect(mockClient.fastSearch).toHaveBeenCalledWith({
+        question: mockResultInstance.title,
+        excludeDocs: [mockResultInstance.url_hash],
+        ...searchParams,
+      });
+      expect(similarResults).toBe(mockResultSet);
+    });
+
+    it("should not return the same document in the result set", async () => {
+      const similarParams = {
+        nResults: 10,
+      };
+
+      const similarResultSet = await realResult.getSimilar(similarParams);
+      const flattenedResults = similarResultSet.getFlattenResults();
+      const resultHashes = flattenedResults.map((r) => r.url_hash);
+
+      expect(resultHashes).not.toContain(realResult.url_hash);
+
+      if (resultHashes.length > 0) {
+        console.log(`Found ${resultHashes.length} similar results`);
+      }
+    }, 15000);
+
+    it("should use the result title as the search question", async () => {
+      const similarParams = {
+        nResults: 10,
+      };
+
+      const similarResultSet = await realResult.getSimilar(similarParams);
+
+      expect(similarResultSet).toBeDefined();
+      expect(similarResultSet.results).toBeDefined();
+
+      console.log(
+        `Search completed successfully using title: "${realResult.title}"`
+      );
+    }, 20000);
+
+    it("should exclude the original document when requesting more results", async () => {
+      const similarParams = {
+        nResults: 10,
+        min_similarity: 0.5,
+      };
+
+      const similarResultSet = await realResult.getSimilar(similarParams);
+      const flattenedResults = similarResultSet.getFlattenResults();
+      const resultHashes = flattenedResults.map((r) => r.url_hash);
+
+      expect(resultHashes).not.toContain(realResult.url_hash);
+
+      console.log(`Original document hash: ${realResult.url_hash}`);
+      console.log(`Found ${resultHashes.length} similar results`);
+    }, 20000);
+
+    it("should handle empty result sets gracefully", async () => {
+      const similarParams = {
+        nResults: 10,
+        min_similarity: 0.99,
+        must_include: ["extremelyrareterm12345"],
+      };
+
+      const similarResultSet = await realResult.getSimilar(similarParams);
+      const flattenedResults = similarResultSet.getFlattenResults();
+      const resultHashes = flattenedResults.map((r) => r.url_hash);
+
+      expect(resultHashes).not.toContain(realResult.url_hash);
+
+      console.log(
+        `High-threshold search returned ${resultHashes.length} results`
+      );
+    }, 20000);
+  });
+
+  describe("scrapeUrl", () => {
+    it("should call client.scrapeUrl with the result URL", async () => {
+      const mockWebPageData = new WebPageData(mockClient, mockScrapeResponse);
+      (mockClient.scrapeUrl as any).mockResolvedValue(mockWebPageData);
+
+      const scrapedData = await mockResultInstance.scrapeUrl();
+
+      expect(mockClient.scrapeUrl).toHaveBeenCalledWith(mockResultInstance.url);
+      expect(scrapedData).toBe(mockWebPageData);
+    });
+  });
+
+  describe("flatten", () => {
+    it("should return a flattened result object with all properties", () => {
+      const flattened: FlattenResult = mockResultInstance.flatten();
+
+      expect(flattened).toEqual({
+        url_hash: "abc123",
+        url: "https://example.com/article",
+        netloc: "example.com",
+        published: "2023-01-15",
+        visited: "2023-01-16",
+        language: "en",
+        author: "John Doe",
+        title: "Test Article Title",
+        description: "This is a test article description",
+        content:
+          "This is the full content of the test article. It contains multiple sentences and provides comprehensive information about the topic being discussed.",
+        best_chunk:
+          "This is the most relevant chunk of content from the article.",
+        origin_shard: 1,
+        chunks_total: 10,
+        chunks_matched: 5,
+        chunks_kept: 3,
+        similarity: 0.85,
+        brand_safety: null,
+        continent: null,
+        region: null,
+        country: null,
+        sector: null,
+        industry_group: null,
+        industry: null,
+        sub_industry: null,
+        iab_tier_1: null,
+        iab_tier_2: null,
+        iab_tier_3: null,
+        iab_tier_4: null,
+      });
+    });
+
+    it("should include set-level fields when they are present", () => {
+      // Create a result with set-level fields by directly manipulating the result instance
+      const resultWithSetFields = new Result({
+        client: mockClient,
+        result: mockResult,
+      });
+
+      // Manually set the fields to test the flatten method
+      resultWithSetFields.brand_safety = "safe";
+      resultWithSetFields.continent = "North America";
+      resultWithSetFields.region = "North America";
+      resultWithSetFields.country = "United States";
+      resultWithSetFields.sector = "Technology";
+      resultWithSetFields.industry_group = "Software";
+      resultWithSetFields.industry = "Enterprise Software";
+      resultWithSetFields.sub_industry = "Business Intelligence";
+      resultWithSetFields.iab_tier_1 = "Technology";
+      resultWithSetFields.iab_tier_2 = "Software";
+      resultWithSetFields.iab_tier_3 = "Business Software";
+      resultWithSetFields.iab_tier_4 = "Analytics";
+
+      const flattened = resultWithSetFields.flatten();
+
+      expect(flattened.brand_safety).toBe("safe");
+      expect(flattened.continent).toBe("North America");
+      expect(flattened.region).toBe("North America");
+      expect(flattened.country).toBe("United States");
+      expect(flattened.sector).toBe("Technology");
+      expect(flattened.industry_group).toBe("Software");
+      expect(flattened.industry).toBe("Enterprise Software");
+      expect(flattened.sub_industry).toBe("Business Intelligence");
+      expect(flattened.iab_tier_1).toBe("Technology");
+      expect(flattened.iab_tier_2).toBe("Software");
+      expect(flattened.iab_tier_3).toBe("Business Software");
+      expect(flattened.iab_tier_4).toBe("Analytics");
+    });
+  });
+
+  describe("data", () => {
+    it("should return a data object with all properties including semantics", () => {
+      const data = mockResultInstance.data();
+
+      expect(data).toEqual({
+        url_hash: "abc123",
+        url: "https://example.com/article",
+        netloc: "example.com",
+        published: "2023-01-15",
+        visited: "2023-01-16",
+        language: "en",
+        author: "John Doe",
+        title: "Test Article Title",
+        description: "This is a test article description",
+        content:
+          "This is the full content of the test article. It contains multiple sentences and provides comprehensive information about the topic being discussed.",
+        best_chunk:
+          "This is the most relevant chunk of content from the article.",
+        brand_safety: null,
+        continent: null,
+        region: null,
+        country: null,
+        sector: null,
+        industry_group: null,
+        industry: null,
+        sub_industry: null,
+        iab_tier_1: null,
+        iab_tier_2: null,
+        iab_tier_3: null,
+        iab_tier_4: null,
+        semantics: mockSemantics,
+      });
+    });
+
+    it("should include set-level fields when they are present", () => {
+      // Create a result with set-level fields by directly manipulating the result instance
+      const resultWithData = new Result({
+        client: mockClient,
+        result: mockResult,
+      });
+
+      // Manually set the fields to test the data method
+      resultWithData.brand_safety = "sensitive";
+      resultWithData.continent = "Europe";
+
+      const data = resultWithData.data();
+
+      expect(data.brand_safety).toBe("sensitive");
+      expect(data.continent).toBe("Europe");
+      expect(data.semantics).toEqual(mockSemantics);
+    });
+  });
+
+  describe("property access", () => {
+    it("should provide direct access to all search response properties", () => {
+      expect(mockResultInstance.url_hash).toBeDefined();
+      expect(mockResultInstance.url).toBeDefined();
+      expect(mockResultInstance.netloc).toBeDefined();
+      expect(mockResultInstance.published).toBeDefined();
+      expect(mockResultInstance.visited).toBeDefined();
+      expect(mockResultInstance.language).toBeDefined();
+      expect(mockResultInstance.author).toBeDefined();
+      expect(mockResultInstance.title).toBeDefined();
+      expect(mockResultInstance.description).toBeDefined();
+      expect(mockResultInstance.content).toBeDefined();
+      expect(mockResultInstance.best_chunk).toBeDefined();
+      expect(mockResultInstance.semantics).toBeDefined();
+    });
+
+    it("should provide access to set-level properties", () => {
+      // Create a result with set-level fields by directly manipulating the result instance
+      const resultWithSetData = new Result({
+        client: mockClient,
+        result: mockResult,
+      });
+
+      // Manually set the fields to test property access
+      resultWithSetData.brand_safety = "unsafe";
+      resultWithSetData.continent = "Asia";
+      resultWithSetData.region = "East Asia";
+      resultWithSetData.country = "Japan";
+
+      expect(resultWithSetData.brand_safety).toBe("unsafe");
+      expect(resultWithSetData.continent).toBe("Asia");
+      expect(resultWithSetData.region).toBe("East Asia");
+      expect(resultWithSetData.country).toBe("Japan");
+    });
+  });
+});