test files to validate functionalities for services including source linking, advanced search, Markdown enhancement, PDF processing, S3 image viewing, and article generation.

Took 42 seconds

Author: mikepsinn

tests/article-generator.test.ts

@@ -0,0 +1,158 @@
+/**
+ * @jest-environment node
+ */
+import fs from 'fs/promises'
+import path from 'path'
+import { ArticleGenerator } from '@/lib/services/article-generator'
+import dotenv from 'dotenv'
+
+// Load environment variables
+dotenv.config({ path: '.env.local' })
+describe("Article Generator", () => {
+  jest.setTimeout(120000) // 2 minute timeout for LLM processing
+
+  const saveArticle = async (filename: string, content: string) => {
+    const testOutputDir = path.join(process.cwd(), 'test-output')
+    await fs.mkdir(testOutputDir, { recursive: true })
+    const absolutePath = path.join(testOutputDir, filename)
+    await fs.writeFile(absolutePath, content, 'utf-8')
+    console.log('\x1b[36m%s\x1b[0m', `📝 Article saved to: ${absolutePath}`)
+    return absolutePath
+  }
+
+  const generateMarkdown = (article: any) => {
+    let markdown = `# ${article.title}\n\n`
+    
+    // Add metadata
+    markdown += `> Generated: ${new Date().toISOString()}\n`
+    markdown += `> Author: ${article.metadata.author}\n`
+    markdown += `> Category: ${article.metadata.categories.join(', ')}\n`
+    markdown += `> Tags: ${article.metadata.tags.join(', ')}\n\n`
+    
+    // Add featured image if available
+    if (article.featured_image) {
+      markdown += `![${article.featured_image_alt}](${article.featured_image})\n\n`
+    }
+    
+    // Add content with images
+    markdown += article.content
+
+    // Add SEO metadata
+    markdown += '\n\n---\n\n'
+    markdown += '## SEO Metadata\n\n'
+    markdown += `- Title: ${article.metadata.seo_title}\n`
+    markdown += `- Description: ${article.metadata.seo_description}\n`
+    markdown += `- Keywords: ${article.metadata.seo_keywords.join(', ')}\n`
+    
+    return markdown
+  }
+
+  it("generates an article with proper source attribution", async () => {
+    // Skip if required environment variables are not set
+    if (!process.env.TAVILY_API_KEY) {
+      throw new Error('TAVILY_API_KEY is not set')
+    }
+    if (!process.env.OPENAI_API_KEY) {
+      throw new Error('OPENAI_API_KEY is not set')
+    }
+
+    const outputDir = path.join(process.cwd(), 'test-output')
+    const articleGenerator = new ArticleGenerator(
+      process.env.TAVILY_API_KEY,
+      outputDir
+    )
+
+    const topic = "Latest developments in quantum computing"
+    await articleGenerator.generateArticle(topic)
+
+    // Check if the article and raw data files were created
+    const articlePath = path.join(
+      outputDir, 
+      'latest-developments-in-quantum-computing.md'
+    )
+    const rawDataPath = path.join(
+      outputDir, 
+      'latest-developments-in-quantum-computing.json'
+    )
+
+    // Read both files
+    const articleContent = await fs.readFile(articlePath, 'utf-8')
+    const rawData = JSON.parse(await fs.readFile(rawDataPath, 'utf-8'))
+    
+    // Check for markdown links
+    const markdownLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g
+    const links = Array.from(articleContent.matchAll(markdownLinkRegex))
+    
+    // Verify we have links
+    expect(links.length).toBeGreaterThan(0)
+    
+    // Get all URLs from the raw search results
+    const sourceUrls = rawData.results.map((result: { url: string }) => result.url)
+    
+    // Get all URLs from the markdown links
+    const linkedUrls = links.map(match => match[2])
+    
+    // Verify that at least some of our source URLs are used in the article
+    const usedSourceUrls = sourceUrls.filter((url: string) => linkedUrls.includes(url))
+    expect(usedSourceUrls.length).toBeGreaterThan(0)
+    
+    // Verify link text is natural (not just "source" or "here")
+    links.forEach(([_, linkText]) => {
+      expect(linkText.toLowerCase()).not.toBe('source')
+      expect(linkText.toLowerCase()).not.toBe('here')
+      expect(linkText.length).toBeGreaterThan(3)
+    })
+
+    // Log link statistics
+    console.log('\x1b[36m%s\x1b[0m', `📝 Link Stats:`)
+    console.log('\x1b[36m%s\x1b[0m', `- Total links: ${links.length}`)
+    console.log('\x1b[36m%s\x1b[0m', `- Unique sources linked: ${new Set(linkedUrls).size}`)
+    console.log('\x1b[36m%s\x1b[0m', `- Source URLs used: ${usedSourceUrls.length}/${sourceUrls.length}`)
+
+    // Log the file location
+    console.log('\x1b[36m%s\x1b[0m', `📝 Article saved to: ${articlePath}`)
+    console.log('\x1b[36m%s\x1b[0m', `📝 Raw data saved to: ${rawDataPath}`)
+  })
+
+  it("generates an article about CRISPR with proper formatting", async () => {
+    // Skip if required environment variables are not set
+    if (!process.env.TAVILY_API_KEY) {
+      throw new Error('TAVILY_API_KEY is not set')
+    }
+    if (!process.env.OPENAI_API_KEY) {
+      throw new Error('OPENAI_API_KEY is not set')
+    }
+
+    const outputDir = path.join(process.cwd(), 'test-output')
+    const articleGenerator = new ArticleGenerator(
+      process.env.TAVILY_API_KEY,
+      outputDir
+    )
+
+    const topic = "CRISPR gene editing technology and its medical applications"
+    await articleGenerator.generateArticle(topic)
+
+    // Check if the article was created
+    const articlePath = path.join(
+      outputDir, 
+      'crispr-gene-editing-technology-and-its-medical-applications.md'
+    )
+    const fileExists = await fs.access(articlePath)
+      .then(() => true)
+      .catch(() => false)
+
+    expect(fileExists).toBe(true)
+
+    // Read and validate the article
+    const articleContent = await fs.readFile(articlePath, 'utf-8')
+    
+    // Content validation
+    expect(articleContent).toContain('CRISPR')
+    expect(articleContent).toMatch(/!\[.*?\]\(.*?\)/) // Should contain images
+    expect(articleContent).toMatch(/\[.*?\]\(.*?\)/) // Should contain links
+    expect(articleContent).toContain('## SEO Metadata') // Should have SEO section
+    
+    // Log the file location
+    console.log('\x1b[36m%s\x1b[0m', `📝 Article saved to: ${articlePath}`)
+  })
+}) 

tests/fdai.test.ts

@@ -20,7 +20,7 @@ describe("FDAi Tests", () => {
       const article = await writeArticle("The most effective experimental treatments for long covid",
           "test-user",
           {
-        modelName: "claude-3-5-sonnet-20240620",
+        //modelName: "claude-3-5-sonnet-20240620",
       })
       console.log(dumpTypeDefinition(article))
       expect(article).not.toBeNull()
@@ -56,7 +56,7 @@ describe("FDAi Tests", () => {
     const result = await doMetaAnalysis("MDMA-Assisted Psychotherapy", "PTSD");
     console.log(result)
     writeFileSync("meta-analysis.json", JSON.stringify(result, null, 2))
-  })
+  }, 60000)
   it("gets dfda access token", async () => {
     const testUser = await getOrCreateTestUser()
     const result = await getOrCreateDfdaAccessToken(testUser.id)

tests/finance-agent.test.ts

@@ -0,0 +1,202 @@
+/**
+ * @jest-environment node
+ */
+import { estimateETFGain, analyzeMultipleIndustries } from "@/lib/finance/finance-agent"
+import { ModelName } from "@/lib/utils/modelUtils"
+
+describe("Finance Agent tests", () => {
+  jest.setTimeout(60000) // 1-minute timeout
+
+  it("estimates ETF gain for Biotechnology industry with different models", async () => {
+    const industryName = "Biotechnology"
+    const models: ModelName[] = [
+      'gemini-1.5-pro',
+      'claude-3-5-sonnet-20240620'
+    ]
+
+    for (const modelName of models) {
+      console.log(`\nTesting with model: ${modelName}`)
+      const result = await estimateETFGain(industryName, modelName)
+
+      // Check the structure of the response
+      expect(result).toHaveProperty("industryName")
+      expect(result).toHaveProperty("parameters")
+      expect(result).toHaveProperty("results")
+      expect(result).toHaveProperty("tokenUsage")
+
+      // Check parameters
+      expect(result.parameters).toHaveProperty("regulatoryCost")
+      expect(result.parameters).toHaveProperty("percentageOfRevenue")
+      expect(result.parameters).toHaveProperty("potentialDecrease")
+      expect(result.parameters).toHaveProperty("netProfitMargin")
+
+      // Validate parameter ranges
+      expect(result.parameters.regulatoryCost).toBeGreaterThan(0)
+      expect(result.parameters.percentageOfRevenue).toBeGreaterThan(0)
+      expect(result.parameters.percentageOfRevenue).toBeLessThan(100)
+      expect(result.parameters.potentialDecrease).toBeGreaterThan(0)
+      expect(result.parameters.potentialDecrease).toBeLessThan(100)
+      expect(result.parameters.netProfitMargin).toBeGreaterThan(0)
+      expect(result.parameters.netProfitMargin).toBeLessThan(100)
+
+      // Check results
+      expect(result.results).toHaveProperty("industryRevenue")
+      expect(result.results).toHaveProperty("currentNetIncome")
+      expect(result.results).toHaveProperty("deltaC")
+      expect(result.results).toHaveProperty("percentIncreaseNetIncome")
+      expect(result.results).toHaveProperty("estimatedETFIncrease")
+
+      // Validate calculations
+      expect(result.results.industryRevenue).toBeGreaterThan(0)
+      expect(result.results.currentNetIncome).toBeGreaterThan(0)
+      expect(result.results.deltaC).toBeGreaterThan(0)
+      expect(result.results.percentIncreaseNetIncome).toBeGreaterThan(0)
+      expect(result.results.estimatedETFIncrease).toBeGreaterThan(0)
+
+      // Optional: Log the result for manual inspection
+      console.log(`${modelName} Analysis:`, JSON.stringify(result, null, 2))
+    }
+  })
+
+  it("estimates ETF gain for Financial Services industry", async () => {
+    const industryName = "Financial Services"
+    const result = await estimateETFGain(industryName)
+
+    // Basic structure checks
+    expect(result).toBeDefined()
+    expect(result.industryName).toBe(industryName)
+    
+    // Check token usage
+    expect(result.tokenUsage).toBeDefined()
+    expect(result.tokenUsage?.totalTokens).toBeGreaterThan(0)
+
+    // Validate that calculations are consistent
+    const { parameters, results } = result
+    
+    // Calculate industry revenue manually to verify
+    const calculatedRevenue = parameters.regulatoryCost / (parameters.percentageOfRevenue / 100)
+    expect(results.industryRevenue).toBeCloseTo(calculatedRevenue, 5)
+
+    // Calculate net income manually to verify
+    const calculatedNetIncome = results.industryRevenue * (parameters.netProfitMargin / 100)
+    expect(results.currentNetIncome).toBeCloseTo(calculatedNetIncome, 5)
+
+    // Calculate regulatory cost savings manually to verify
+    const calculatedSavings = parameters.regulatoryCost * (parameters.potentialDecrease / 100)
+    expect(results.deltaC).toBeCloseTo(calculatedSavings, 5)
+
+    console.log("Financial Services Analysis:", JSON.stringify(result, null, 2))
+  })
+
+  it("provides consistent results for the same industry", async () => {
+    const industryName = "Healthcare"
+    
+    // Make two separate calls
+    const result1 = await estimateETFGain(industryName)
+    const result2 = await estimateETFGain(industryName)
+
+    // Results should be similar but not identical due to AI variation
+    // We'll check if they're within reasonable ranges of each other
+    const marginOfError = 0.5 // 50% margin to account for AI variation
+    
+    expect(
+      Math.abs(result1.parameters.regulatoryCost - result2.parameters.regulatoryCost) / 
+      result1.parameters.regulatoryCost
+    ).toBeLessThan(marginOfError)
+
+    expect(
+      Math.abs(result1.parameters.percentageOfRevenue - result2.parameters.percentageOfRevenue) / 
+      result1.parameters.percentageOfRevenue
+    ).toBeLessThan(marginOfError)
+
+    console.log("Consistency Test Results:", {
+      firstCall: result1,
+      secondCall: result2
+    })
+  })
+
+  it("analyzes multiple industries with different models", async () => {
+    const industries = [
+      "Biotechnology",
+      "Financial Services",
+      "Healthcare"
+    ];
+
+    const models: ModelName[] = [
+      'gemini-1.5-pro',
+      'claude-3-5-sonnet-20240620'
+    ]
+
+    for (const modelName of models) {
+      console.log(`\n=== Testing with model: ${modelName} ===`)
+      
+      const results = await analyzeMultipleIndustries(industries, modelName);
+
+      // Check we got results for all industries
+      expect(results.length).toBe(industries.length);
+
+      // Check results are sorted by ETF increase
+      for (let i = 0; i < results.length - 1; i++) {
+        expect(results[i].results.estimatedETFIncrease)
+          .toBeGreaterThanOrEqual(results[i + 1].results.estimatedETFIncrease);
+      }
+
+      // Verify structure of each result
+      results.forEach(result => {
+        // Check basic structure
+        expect(result).toHaveProperty("industryName");
+        expect(result).toHaveProperty("parameters");
+        expect(result).toHaveProperty("results");
+        
+        // Check parameters are within reasonable ranges
+        expect(result.parameters.regulatoryCost).toBeGreaterThan(0);
+        expect(result.parameters.percentageOfRevenue).toBeLessThan(100);
+        expect(result.parameters.potentialDecrease).toBeLessThan(100);
+        expect(result.parameters.netProfitMargin).toBeLessThan(100);
+
+        // Verify calculations for each industry
+        const calculatedRevenue = result.parameters.regulatoryCost / 
+          (result.parameters.percentageOfRevenue / 100);
+        expect(result.results.industryRevenue).toBeCloseTo(calculatedRevenue, 5);
+      });
+
+      // Check that industries are unique
+      const uniqueIndustries = new Set(results.map(r => r.industryName));
+      expect(uniqueIndustries.size).toBe(industries.length);
+
+      console.log(`\n${modelName} Multi-Industry Analysis:`, 
+        JSON.stringify(results, null, 2));
+    }
+  }, 480000); // 8-minute timeout for multiple models and industries
+
+  it("compares results between different models", async () => {
+    const industryName = "Healthcare";
+    const models: ModelName[] = [
+      'gemini-1.5-pro',
+      'claude-3-5-sonnet-20240620'
+    ];
+
+    const results = await Promise.all(
+      models.map(model => estimateETFGain(industryName, model))
+    );
+
+    // Compare results between models
+    results.forEach((result, i) => {
+      console.log(`\n${models[i]} results:`)
+      console.log(`ETF Increase: ${result.results.estimatedETFIncrease.toFixed(2)}%`)
+      console.log(`Regulatory Cost: $${result.parameters.regulatoryCost.toFixed(2)}B`)
+      console.log(`Token Usage: ${result.tokenUsage?.totalTokens || 'N/A'}`)
+    });
+
+    // Check that results are within reasonable ranges of each other
+    const marginOfError = 0.5; // 50% margin
+    for (let i = 0; i < results.length - 1; i++) {
+      const ratio = Math.abs(
+        results[i].results.estimatedETFIncrease - 
+        results[i + 1].results.estimatedETFIncrease
+      ) / results[i].results.estimatedETFIncrease;
+      
+      expect(ratio).toBeLessThan(marginOfError);
+    }
+  }, 120000); // 2-minute timeout for model comparison
+})