evaldoc 1.0.0

package/tests/unit/topics-limits.test.js

@@ -0,0 +1,158 @@
+const { TOPICS, TOPIC_KEYS, inferTopic } = require('../../functions/src/topics');
+
+describe('Topics Module', () => {
+  describe('Topic Definitions', () => {
+    it('should define exactly 6 topics matching SRS', () => {
+      expect(TOPIC_KEYS).toEqual([
+        'medication_info_safety',
+        'appointments_preparation',
+        'general_health_info',
+        'clinic_services_hours',
+        'insurance_billing_faq',
+        'post_procedure_guidance'
+      ]);
+    });
+
+    it.each(TOPIC_KEYS)('%s should have all required fields', (key) => {
+      const topic = TOPICS[key];
+      expect(topic.title).toBeDefined();
+      expect(typeof topic.title).toBe('string');
+      expect(topic.disclaimer).toBeDefined();
+      expect(typeof topic.disclaimer).toBe('string');
+      expect(topic.prompt).toBeDefined();
+      expect(typeof topic.prompt).toBe('string');
+      expect(Array.isArray(topic.forbiddenPatterns)).toBe(true);
+      expect(Array.isArray(topic.escalationTriggers)).toBe(true);
+    });
+
+    it('medication topic should forbid dosing keywords', () => {
+      const patterns = TOPICS.medication_info_safety.forbiddenPatterns;
+      expect(patterns.some(p => p.test('take 500mg'))).toBe(true);
+      expect(patterns.some(p => p.test('dose of 2 tablets'))).toBe(true);
+    });
+
+    it('medication topic should not forbid general questions', () => {
+      const patterns = TOPICS.medication_info_safety.forbiddenPatterns;
+      expect(patterns.some(p => p.test('What is aspirin used for?'))).toBe(false);
+    });
+
+    it('insurance topic should forbid SSN', () => {
+      const patterns = TOPICS.insurance_billing_faq.forbiddenPatterns;
+      expect(patterns.some(p => p.test('my social security number is'))).toBe(true);
+    });
+
+    it('post-procedure topic should escalate on severe pain', () => {
+      const triggers = TOPICS.post_procedure_guidance.escalationTriggers;
+      expect(triggers.some(t => t.test('I have severe pain'))).toBe(true);
+      expect(triggers.some(t => t.test('uncontrolled bleeding'))).toBe(true);
+    });
+
+    it('general health topic should escalate on red flags', () => {
+      const triggers = TOPICS.general_health_info.escalationTriggers;
+      expect(triggers.some(t => t.test('I have chest pain'))).toBe(true);
+      expect(triggers.some(t => t.test('severe bleeding'))).toBe(true);
+    });
+  });
+
+  describe('inferTopic', () => {
+    it('should infer appointments_preparation from scheduling keywords', () => {
+      expect(inferTopic('How do I schedule an appointment?')).toBe('appointments_preparation');
+      expect(inferTopic('What should I bring to my visit?')).toBe('appointments_preparation');
+    });
+
+    it('should infer clinic_services_hours from hours/location keywords', () => {
+      expect(inferTopic('What are your hours?')).toBe('clinic_services_hours');
+      expect(inferTopic('Where is the clinic located?')).toBe('clinic_services_hours');
+      expect(inferTopic('Is there parking?')).toBe('clinic_services_hours');
+    });
+
+    it('should infer insurance_billing_faq from billing keywords', () => {
+      expect(inferTopic('Do you accept insurance?')).toBe('insurance_billing_faq');
+      expect(inferTopic('How much is the copay?')).toBe('insurance_billing_faq');
+    });
+
+    it('should infer post_procedure_guidance from post-op keywords', () => {
+      expect(inferTopic('Recovery after surgery')).toBe('post_procedure_guidance');
+      expect(inferTopic('post procedure care tips')).toBe('post_procedure_guidance');
+    });
+
+    it('should infer medication_info_safety from drug keywords', () => {
+      expect(inferTopic('Tell me about this medicine')).toBe('medication_info_safety');
+      expect(inferTopic('What are the side effects?')).toBe('medication_info_safety');
+    });
+
+    it('should default to general_health_info', () => {
+      expect(inferTopic('I have a headache')).toBe('general_health_info');
+      expect(inferTopic('Is it normal to feel tired?')).toBe('general_health_info');
+      expect(inferTopic('')).toBe('general_health_info');
+      expect(inferTopic(null)).toBe('general_health_info');
+    });
+  });
+});
+
+describe('Limits Module', () => {
+  jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+  const { checkMonthlyLimit } = require('../../functions/src/limits');
+  const { getMonthKey } = require('../../functions/src/analytics');
+
+  function makeProviderDoc(data) {
+    return { data: () => data, ref: { set: jest.fn() } };
+  }
+
+  it('should allow chat when under limit', async () => {
+    const doc = makeProviderDoc({
+      monthlyChatLimit: 50,
+      monthlyChatCount: 10,
+      monthlyChatCountMonth: getMonthKey()
+    });
+
+    const result = await checkMonthlyLimit({ providerDoc: doc });
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should block chat when at limit', async () => {
+    const doc = makeProviderDoc({
+      monthlyChatLimit: 50,
+      monthlyChatCount: 50,
+      monthlyChatCountMonth: getMonthKey()
+    });
+
+    const result = await checkMonthlyLimit({ providerDoc: doc });
+    expect(result.allowed).toBe(false);
+    expect(result.message).toMatch(/monthly.*limit/i);
+  });
+
+  it('should allow chat when no limit set', async () => {
+    const doc = makeProviderDoc({
+      monthlyChatLimit: 0,
+      monthlyChatCount: 999
+    });
+
+    const result = await checkMonthlyLimit({ providerDoc: doc });
+    expect(result.allowed).toBe(true);
+  });
+
+  it('should reset count when month changes', async () => {
+    const doc = makeProviderDoc({
+      monthlyChatLimit: 50,
+      monthlyChatCount: 50,
+      monthlyChatCountMonth: '2025-01'
+    });
+
+    const result = await checkMonthlyLimit({ providerDoc: doc });
+    expect(result.allowed).toBe(true);
+    expect(result.resetNeeded).toBe(true);
+  });
+
+  it('should not reset when month is current', async () => {
+    const doc = makeProviderDoc({
+      monthlyChatLimit: 50,
+      monthlyChatCount: 10,
+      monthlyChatCountMonth: getMonthKey()
+    });
+
+    const result = await checkMonthlyLimit({ providerDoc: doc });
+    expect(result.resetNeeded).toBeFalsy();
+  });
+});

package/tests/unit/triage.test.js

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for triage classification module
+ */
+
+// Mock LLM clients before requiring the module
+jest.mock('openai', () => {
+  return jest.fn().mockImplementation(() => ({
+    chat: {
+      completions: {
+        create: jest.fn().mockResolvedValue({
+          choices: [{ message: { content: '{"category":"needs_review","confidence":0.8,"reason":"Patient asking medical question"}' } }]
+        })
+      }
+    }
+  }));
+});
+
+jest.mock('@google/generative-ai', () => ({
+  GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
+    getGenerativeModel: () => ({
+      generateContent: jest.fn().mockResolvedValue({
+        response: {
+          text: () => '{"category":"informational","confidence":0.9,"reason":"General inquiry"}'
+        }
+      })
+    })
+  }))
+}));
+
+// Set API keys so LLM paths are taken
+process.env.GEMINI_API_KEY = 'test-gemini-key';
+process.env.DEEPSEEK_API_KEY = 'test-deepseek-key';
+
+const { classifyConversation, TRIAGE_CATEGORIES } = require('../../functions/src/triage');
+
+describe('Triage Classification', () => {
+  describe('TRIAGE_CATEGORIES', () => {
+    it('should export 4 categories', () => {
+      expect(TRIAGE_CATEGORIES).toHaveLength(4);
+      expect(TRIAGE_CATEGORIES).toEqual(['urgent', 'needs_review', 'informational', 'resolved']);
+    });
+  });
+
+  describe('classifyConversation', () => {
+    it('should return urgent when isEscalated is true', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'hello' }],
+        isEscalated: true
+      });
+
+      expect(result.category).toBe('urgent');
+      expect(result.confidence).toBe(1.0);
+      expect(result.reason).toMatch(/escalation/i);
+    });
+
+    it('should return informational for empty messages', async () => {
+      const result = await classifyConversation({
+        messages: [],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('informational');
+      expect(result.confidence).toBe(0.5);
+    });
+
+    it('should return a valid triage category from LLM', async () => {
+      const result = await classifyConversation({
+        messages: [
+          { role: 'user', content: 'What are common treatments for migraines?' },
+          { role: 'assistant', content: 'There are several approaches to migraine treatment...' }
+        ],
+        isEscalated: false
+      });
+
+      expect(TRIAGE_CATEGORIES).toContain(result.category);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+      expect(typeof result.reason).toBe('string');
+    });
+
+    it('should handle null messages gracefully', async () => {
+      const result = await classifyConversation({
+        messages: null,
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('informational');
+    });
+  });
+
+  describe('Rule-based fallback (no LLM)', () => {
+    // Temporarily remove API keys to force rule-based fallback
+    let savedGemini, savedDeepSeek;
+
+    beforeAll(() => {
+      savedGemini = process.env.GEMINI_API_KEY;
+      savedDeepSeek = process.env.DEEPSEEK_API_KEY;
+      delete process.env.GEMINI_API_KEY;
+      delete process.env.DEEPSEEK_API_KEY;
+    });
+
+    afterAll(() => {
+      process.env.GEMINI_API_KEY = savedGemini;
+      process.env.DEEPSEEK_API_KEY = savedDeepSeek;
+    });
+
+    it('should detect urgent keywords (chest pain)', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'I am having chest pain and cannot breathe' }],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('urgent');
+    });
+
+    it('should detect urgent keywords (seizure)', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'My child is having a seizure' }],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('urgent');
+    });
+
+    it('should detect resolved signals', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'Thank you, that helps a lot!' }],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('resolved');
+    });
+
+    it('should detect questions as needs_review', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'What medication should I take for this?' }],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('needs_review');
+    });
+
+    it('should default to informational for generic messages', async () => {
+      const result = await classifyConversation({
+        messages: [{ role: 'user', content: 'I wanted to share some information with you' }],
+        isEscalated: false
+      });
+
+      expect(result.category).toBe('informational');
+    });
+  });
+});