evaldoc 1.0.0

package/tests/unit/safety-srs-compliance.test.js

@@ -0,0 +1,252 @@
+/**
+ * Deep safety pipeline tests — SRS sections 7.1, 7.2, 7.3 compliance
+ *
+ * Every blocked/escalation pattern from the SRS is tested individually.
+ */
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+const {
+  analyzeInput,
+  analyzeOutput,
+  redactText,
+  refusalMessage,
+  escalationMessage,
+  INPUT_BLOCKED,
+  OUTPUT_BLOCKED,
+  GLOBAL_REDFLAGS,
+  PII_PATTERNS
+} = require('../../functions/src/safety');
+
+describe('SRS 7.1 — Always Block (Input)', () => {
+  describe('Diagnosis claims', () => {
+    it('should block "give me a diagnosis"', async () => {
+      const result = await analyzeInput('give me a diagnosis');
+      expect(result.blocked).toBe(true);
+    });
+  });
+
+  describe('Treatment instructions', () => {
+    it('should block "prescribe me something"', async () => {
+      const result = await analyzeInput('prescribe me antibiotics');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "write me a prescription"', async () => {
+      const result = await analyzeInput('write me a prescription for pain');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "recommend medication"', async () => {
+      const result = await analyzeInput('recommend medication for my cold');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "best treatment for"', async () => {
+      const result = await analyzeInput('what is the best treatment for flu?');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "what should I take for"', async () => {
+      const result = await analyzeInput('what should i take for a headache?');
+      expect(result.blocked).toBe(true);
+    });
+  });
+
+  describe('Dosing instructions', () => {
+    it('should block "how many tablets"', async () => {
+      const result = await analyzeInput('how many tablets should I take?');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "how many pills"', async () => {
+      const result = await analyzeInput('how many pills do I need?');
+      expect(result.blocked).toBe(true);
+    });
+  });
+
+  describe('Off-label suggestions', () => {
+    it('should block "off-label" mentions', async () => {
+      const result = await analyzeInput('can I use this off-label?');
+      expect(result.blocked).toBe(true);
+    });
+  });
+
+  describe('Medical image interpretation', () => {
+    it('should block "interpret my x-ray"', async () => {
+      const result = await analyzeInput('can you interpret my x-ray results?');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "interpret my MRI"', async () => {
+      const result = await analyzeInput('interpret my MRI scan please');
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "image shows"', async () => {
+      const result = await analyzeInput('the image shows a dark spot');
+      expect(result.blocked).toBe(true);
+    });
+  });
+
+  describe('Safe inputs should NOT be blocked', () => {
+    it('should allow general health questions', async () => {
+      const result = await analyzeInput('What are the symptoms of a cold?');
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow appointment questions', async () => {
+      const result = await analyzeInput('How do I schedule an appointment?');
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow insurance questions', async () => {
+      const result = await analyzeInput('Do you accept Blue Cross insurance?');
+      expect(result.blocked).toBe(false);
+    });
+  });
+});
+
+describe('SRS 7.1 — Always Block (Output)', () => {
+  it('should block "you have [condition]"', () => {
+    const result = analyzeOutput('You have diabetes based on your symptoms');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should NOT block "you have questions"', () => {
+    const result = analyzeOutput('If you have questions, please ask');
+    expect(result.blocked).toBe(false);
+  });
+
+  it('should NOT block "you have concerns"', () => {
+    const result = analyzeOutput('If you have concerns, consult your doctor');
+    expect(result.blocked).toBe(false);
+  });
+
+  it('should block "you are suffering from"', () => {
+    const result = analyzeOutput('You are suffering from depression');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block "this is likely"', () => {
+    const result = analyzeOutput('this is likely a bacterial infection');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block dosing: "take 500mg"', () => {
+    const result = analyzeOutput('Take 500mg of ibuprofen twice daily');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block "start taking"', () => {
+    const result = analyzeOutput('You should start taking metformin');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block "stop using"', () => {
+    const result = analyzeOutput('Stop using aspirin immediately');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block "looks like pneumonia"', () => {
+    const result = analyzeOutput('This looks like pneumonia on the scan');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should block "not approved but"', () => {
+    const result = analyzeOutput('This drug is not approved but some doctors use it');
+    expect(result.blocked).toBe(true);
+  });
+
+  it('should allow safe informational responses', () => {
+    const result = analyzeOutput('Here is some general information about cold symptoms. Please consult your doctor for specific advice.');
+    expect(result.blocked).toBe(false);
+  });
+});
+
+describe('SRS 7.2 — Always Escalate (Red Flags)', () => {
+  it.each([
+    ['chest pain', 'I am having chest pain'],
+    ['trouble breathing', 'I have trouble breathing'],
+    ['difficulty breathing', 'having difficulty breathing'],
+    ['seizure', 'I just had a seizure'],
+    ['fainting', 'I keep fainting'],
+    ['stroke signs', 'sudden weakness and slurred speech'],
+    ['severe bleeding', 'there is severe bleeding'],
+    ['suicidal thoughts', 'I am feeling suicidal'],
+    ['self-harm', 'thoughts of self-harm'],
+    ['want to die', 'I want to die'],
+    ['pregnancy + bleeding', 'I am pregnant and having bleeding'],
+    ['pregnancy + severe pain', 'pregnant with severe pain'],
+    ['newborn severe symptoms', 'my newborn has difficulty breathing'],
+    ['severe allergic reaction', 'severe allergic reaction'],
+    ['anaphylaxis', 'I think I am having anaphylaxis'],
+    ['swelling face/throat', 'swelling in my throat'],
+    ['unconscious', 'my father is unconscious'],
+    ['overdose', 'I think I took too many pills'],
+    ['vision loss', 'sudden vision loss in one eye'],
+  ])('should escalate: %s', async (label, message) => {
+    const result = await analyzeInput(message);
+    expect(result.escalated).toBe(true);
+    expect(result.flags).toContain('red_flag');
+  });
+
+  it('should NOT escalate normal questions', async () => {
+    const result = await analyzeInput('What time does the clinic open?');
+    expect(result.escalated).toBe(false);
+  });
+});
+
+describe('PII Detection & Redaction', () => {
+  it('should detect SSN', async () => {
+    const result = await analyzeInput('My SSN is 123-45-6789');
+    expect(result.flags).toContain('pii_detected');
+  });
+
+  it('should detect email', async () => {
+    const result = await analyzeInput('Contact me at test@example.com');
+    expect(result.flags).toContain('pii_detected');
+  });
+
+  it('should redact SSN', () => {
+    expect(redactText('My SSN is 123-45-6789')).toContain('[redacted]');
+    expect(redactText('My SSN is 123-45-6789')).not.toContain('123-45-6789');
+  });
+
+  it('should redact email addresses', () => {
+    const result = redactText('Email me at john@example.com');
+    expect(result).toContain('[redacted]');
+    expect(result).not.toContain('john@example.com');
+  });
+
+  it('should redact street addresses', () => {
+    const result = redactText('I live at 123 Main Street');
+    expect(result).toContain('[redacted address]');
+  });
+
+  it('should redact dates of birth', () => {
+    const result = redactText('DOB: 01/15/1990');
+    expect(result).toContain('[redacted DOB]');
+  });
+
+  it('should redact credit-card numbers', () => {
+    expect(redactText('my card is 4111 1111 1111 1111')).not.toContain('4111');
+    expect(redactText('card 4111111111111111')).toContain('[redacted]');
+  });
+
+  it('should preserve non-PII text', () => {
+    expect(redactText('I have a headache')).toBe('I have a headache');
+  });
+});
+
+describe('Safety Module Exports', () => {
+  it('refusalMessage should return a safe refusal', () => {
+    const msg = refusalMessage();
+    expect(msg).toMatch(/can't help|licensed clinician/i);
+  });
+
+  it('escalationMessage should urge seeking care', () => {
+    const msg = escalationMessage();
+    expect(msg).toMatch(/urgent|emergency|professional care/i);
+  });
+});

package/tests/unit/safety.test.js

@@ -0,0 +1,291 @@
+/**
+ * Unit tests for the re-enabled safety filter module.
+ *
+ * Verifies that:
+ *   - Dangerous input patterns are blocked
+ *   - Safe medical questions pass through
+ *   - Output filter catches definitive clinical statements
+ *   - Output filter allows safe disclaimer phrasing
+ *   - PII is detected and redacted
+ *   - Red-flag escalation works for emergencies
+ */
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+// Mock NER to avoid external API calls
+jest.mock('../../functions/src/ner', () => ({
+  analyzeMedicalSafety: jest.fn().mockResolvedValue({
+    entities: [],
+    analysis: {},
+    shouldEscalate: false,
+    requiresDisclaimer: false
+  })
+}));
+
+const {
+  analyzeInput,
+  analyzeOutput,
+  redactText,
+  INPUT_BLOCKED,
+  OUTPUT_BLOCKED,
+  GLOBAL_REDFLAGS,
+  PII_PATTERNS
+} = require('../../functions/src/safety');
+
+const topicConfig = { forbiddenPatterns: [] };
+
+describe('Safety Filter', () => {
+  // ============================================
+  // INPUT ANALYSIS
+  // ============================================
+
+  describe('analyzeInput', () => {
+    it('should block "prescribe me" requests', async () => {
+      const result = await analyzeInput('prescribe me amoxicillin', topicConfig);
+      expect(result.blocked).toBe(true);
+      expect(result.flags).toContain('blocked_input');
+    });
+
+    it('should block "give me a diagnosis" requests', async () => {
+      const result = await analyzeInput('give me a diagnosis for my rash', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "write me a prescription"', async () => {
+      const result = await analyzeInput('write me a prescription for painkillers', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should allow normal health questions', async () => {
+      const result = await analyzeInput('What causes headaches?', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow asking about symptoms', async () => {
+      const result = await analyzeInput('I have a sore throat, what should I do?', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow questions about treatment in general', async () => {
+      const result = await analyzeInput('What are treatment options for allergies?', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow questions about diagnosis process', async () => {
+      const result = await analyzeInput('How is diabetes diagnosed?', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    // New expanded input blocks (SRS Section 7)
+    it('should block "recommend medication" requests', async () => {
+      const result = await analyzeInput('Can you recommend medication for my pain?', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "best treatment for" requests', async () => {
+      const result = await analyzeInput('What is the best treatment for my condition?', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "what should I take for" requests', async () => {
+      const result = await analyzeInput('What should I take for a headache?', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "how many tablets" requests', async () => {
+      const result = await analyzeInput('How many tablets should I take?', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block image interpretation requests', async () => {
+      const result = await analyzeInput('Can you interpret my x-ray results?', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    // Red flag escalation
+    it('should escalate chest pain', async () => {
+      const result = await analyzeInput('I have chest pain and shortness of breath', topicConfig);
+      expect(result.escalated).toBe(true);
+      expect(result.flags).toContain('red_flag');
+    });
+
+    it('should escalate suicidal ideation', async () => {
+      const result = await analyzeInput('I feel suicidal', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate severe bleeding', async () => {
+      const result = await analyzeInput('I have severe bleeding from a wound', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate severe allergic reaction', async () => {
+      const result = await analyzeInput('I am having a severe allergic reaction', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate unconsciousness', async () => {
+      const result = await analyzeInput('My father is unconscious and not responding', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate sudden vision loss', async () => {
+      const result = await analyzeInput('I just had sudden vision loss in one eye', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate overdose', async () => {
+      const result = await analyzeInput('I took too many pills', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    it('should escalate "want to die"', async () => {
+      const result = await analyzeInput('I want to die', topicConfig);
+      expect(result.escalated).toBe(true);
+    });
+
+    // PII detection
+    it('should flag SSN in input', async () => {
+      const result = await analyzeInput('my SSN is 123-45-6789', topicConfig);
+      expect(result.flags).toContain('pii_detected');
+    });
+
+    it('should flag email in input', async () => {
+      const result = await analyzeInput('email me at patient@example.com', topicConfig);
+      expect(result.flags).toContain('pii_detected');
+    });
+  });
+
+  // ============================================
+  // OUTPUT ANALYSIS
+  // ============================================
+
+  describe('analyzeOutput', () => {
+    it('should block "you have diabetes" (definitive diagnosis)', () => {
+      const result = analyzeOutput('Based on your symptoms, you have diabetes.', topicConfig);
+      expect(result.blocked).toBe(true);
+      expect(result.flags).toContain('blocked_output');
+    });
+
+    it('should block specific dosing instructions', () => {
+      const result = analyzeOutput('Take 200mg ibuprofen twice daily.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "start taking" imperative advice', () => {
+      const result = analyzeOutput('You should start taking metformin now.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "stop taking" imperative advice', () => {
+      const result = analyzeOutput('You should stop taking your medication.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "you are suffering from" diagnosis', () => {
+      const result = analyzeOutput('You are suffering from an infection.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block "this is likely" diagnosis', () => {
+      const result = analyzeOutput('This is likely a bacterial infection.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block off-label suggestions', () => {
+      const result = analyzeOutput('It is not approved but some people try it for pain.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should block image-based tumor diagnosis', () => {
+      const result = analyzeOutput('This looks like cancer based on the image.', topicConfig);
+      expect(result.blocked).toBe(true);
+    });
+
+    it('should allow "I cannot provide a diagnosis"', () => {
+      const result = analyzeOutput('I cannot provide a diagnosis. Please consult your doctor.', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow "consult your doctor for treatment"', () => {
+      const result = analyzeOutput('You should consult your doctor for treatment options.', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow "you have questions" phrasing', () => {
+      const result = analyzeOutput('If you have questions, contact your provider.', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow "you have concerns" phrasing', () => {
+      const result = analyzeOutput('If you have concerns about your symptoms, see a doctor.', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow "you have options" phrasing', () => {
+      const result = analyzeOutput('You have options for managing your condition.', topicConfig);
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow general health education', () => {
+      const result = analyzeOutput(
+        'Headaches can be caused by dehydration, stress, or lack of sleep. ' +
+        'Drinking water and resting often helps. If headaches persist, see your doctor.',
+        topicConfig
+      );
+      expect(result.blocked).toBe(false);
+    });
+
+    it('should allow mentioning "diagnosis" in disclaimers', () => {
+      const result = analyzeOutput(
+        'Only a licensed healthcare provider can make a diagnosis. I can share general information.',
+        topicConfig
+      );
+      expect(result.blocked).toBe(false);
+    });
+  });
+
+  // ============================================
+  // PII REDACTION
+  // ============================================
+
+  describe('redactText', () => {
+    it('should redact SSN', () => {
+      expect(redactText('SSN: 123-45-6789')).toBe('SSN: [redacted]');
+    });
+
+    it('should redact email', () => {
+      expect(redactText('contact me at user@example.com please')).toBe('contact me at [redacted] please');
+    });
+
+    it('should redact 10-digit phone numbers', () => {
+      expect(redactText('call 1234567890')).toBe('call [redacted]');
+    });
+
+    it('should redact street addresses', () => {
+      expect(redactText('I live at 123 Main Street')).toContain('[redacted');
+    });
+
+    it('should redact ZIP codes with context', () => {
+      expect(redactText('My zip code is 90210')).toContain('[redacted');
+    });
+
+    it('should not redact bare 5-digit numbers', () => {
+      expect(redactText('I took 10000 steps today')).toBe('I took 10000 steps today');
+    });
+
+    it('should redact dates of birth', () => {
+      expect(redactText('My DOB is 03/15/1990')).toContain('[redacted');
+    });
+
+    it('should handle text with no PII', () => {
+      const clean = 'I have a headache and feel tired';
+      expect(redactText(clean)).toBe(clean);
+    });
+
+    it('should handle empty/null input', () => {
+      expect(redactText('')).toBe('');
+      expect(redactText(null)).toBe('');
+    });
+  });
+});