evaldoc 1.0.0

package/tests/integration/api-chat-satisfaction.test.js

@@ -0,0 +1,259 @@
+process.env.NODE_ENV = 'test';
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+jest.mock('stripe', () => jest.fn().mockReturnValue({}));
+jest.mock('openai', () => jest.fn().mockImplementation(() => ({
+  chat: { completions: { create: jest.fn().mockResolvedValue({ choices: [{ message: { content: 'This is general health information. *This is not medical advice.*' } }] }) } }
+})));
+jest.mock('@google/generative-ai', () => ({
+  GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
+    getGenerativeModel: () => ({
+      generateContent: jest.fn().mockResolvedValue({ response: { text: () => 'mock' } })
+    })
+  }))
+}));
+jest.mock('../../functions/src/stripe-config', () => ({ stripe: {} }));
+jest.mock('../../functions/src/payment', () => ({
+  createConnectAccount: jest.fn(),
+  createAccountLink: jest.fn(),
+  refreshAccountStatus: jest.fn(),
+  setProviderPricing: jest.fn(),
+  createCheckoutSession: jest.fn(),
+  createPaymentIntent: jest.fn(),
+  createSubscription: jest.fn(),
+  cancelSubscription: jest.fn(),
+  checkPaymentAccess: jest.fn(),
+  getRevenueAnalytics: jest.fn(),
+  handleStripeWebhook: jest.fn()
+}));
+
+process.env.DEEPSEEK_API_KEY = 'test-key';
+process.env.GEMINI_API_KEY = 'test-key';
+
+const request = require('supertest');
+const admin = require('firebase-admin');
+
+admin.auth().verifyIdToken = jest.fn(async (token) => {
+  if (token === 'valid-doctor-token') return { uid: 'doctor-uid-1', email: 'doc@test.com' };
+  throw new Error('Invalid token');
+});
+
+const app = require('../../server');
+
+describe('Chat, Satisfaction & History API', () => {
+  beforeEach(() => {
+    admin.__reset();
+    admin.__seed('providers', 'doctor-uid-1', {
+      ownerUid: 'doctor-uid-1',
+      handle: 'drsmith',
+      displayName: 'Dr. Smith',
+      specialty: 'General',
+      status: 'published',
+      enabledTopics: ['general_health_info'],
+      plan: 'free',
+      monthlyChatLimit: 50,
+      monthlyChatCount: 5,
+      monthlyChatCountMonth: new Date().toISOString().slice(0, 7),
+      contactInfo: null,
+      businessHours: null
+    });
+    admin.__seed('handles', 'drsmith', { providerId: 'doctor-uid-1' });
+  });
+
+  describe('POST /api/satisfaction', () => {
+    it('should accept a valid rating from the owning session', async () => {
+      admin.__seed('conversations', 'conv-1', { providerId: 'doctor-uid-1', sessionId: 'sess-own' });
+
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'conv-1', sessionId: 'sess-own', rating: 4 });
+
+      expect(res.status).toBe(200);
+      expect(res.body.ok).toBe(true);
+    });
+
+    it('should accept a rating against a thread owned by the session', async () => {
+      admin.__seed('threads', 'thread-sat', { doctorId: 'doctor-uid-1', sessionId: 'sess-own' });
+
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'thread-sat', sessionId: 'sess-own', rating: 5 });
+
+      expect(res.status).toBe(200);
+    });
+
+    it('should reject a rating from a non-owning session (IDOR)', async () => {
+      admin.__seed('conversations', 'conv-1', { providerId: 'doctor-uid-1', sessionId: 'sess-own' });
+
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'conv-1', sessionId: 'sess-attacker', rating: 1 });
+
+      expect(res.status).toBe(403);
+    });
+
+    it('should not create a conversation doc for an unknown id', async () => {
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'does-not-exist', sessionId: 'sess-x', rating: 3 });
+
+      expect(res.status).toBe(404);
+    });
+
+    it('should reject missing conversationId', async () => {
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ rating: 5, sessionId: 'sess-own' });
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject missing sessionId', async () => {
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'conv-1', rating: 5 });
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject invalid rating value', async () => {
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'conv-1', sessionId: 'sess-own', rating: 0 });
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject rating above 5', async () => {
+      const res = await request(app)
+        .post('/api/satisfaction')
+        .send({ conversationId: 'conv-1', sessionId: 'sess-own', rating: 6 });
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('GET /api/chat/history', () => {
+    it('should return empty array for new session', async () => {
+      const res = await request(app)
+        .get('/api/chat/history?handle=drsmith&sessionId=new-session');
+
+      expect(res.status).toBe(200);
+      expect(res.body.messages).toEqual([]);
+      expect(res.body.hasMore).toBe(false);
+    });
+
+    it('should return messages from existing thread', async () => {
+      const threadId = 'thread_anon_sess-123_doctor-uid-1';
+      admin.__seed('threads', threadId, {
+        doctorId: 'doctor-uid-1',
+        sessionId: 'sess-123',
+        status: 'active'
+      });
+      admin.__seed(`threads/${threadId}/messages`, 'msg-1', {
+        role: 'user',
+        content: 'Hello doctor',
+        createdAt: { _seconds: 1000 }
+      });
+      admin.__seed(`threads/${threadId}/messages`, 'msg-2', {
+        role: 'assistant',
+        content: 'Hello, how can I help?',
+        createdAt: { _seconds: 1001 }
+      });
+
+      const res = await request(app)
+        .get('/api/chat/history?handle=drsmith&sessionId=sess-123');
+
+      expect(res.status).toBe(200);
+      expect(res.body.messages.length).toBe(2);
+      expect(res.body.messages[0].role).toBe('user');
+      expect(res.body.messages[1].role).toBe('assistant');
+    });
+
+    it('should reject missing handle or sessionId', async () => {
+      const res = await request(app)
+        .get('/api/chat/history?handle=drsmith');
+
+      expect(res.status).toBe(400);
+    });
+  });
+
+  describe('GET /api/me', () => {
+    it('should return current provider profile', async () => {
+      admin.__seed('providers', 'doctor-uid-1', {
+        ownerUid: 'doctor-uid-1',
+        handle: 'drsmith',
+        displayName: 'Dr. Smith',
+        specialty: 'General',
+        status: 'published',
+        enabledTopics: ['general_health_info'],
+        plan: 'free',
+        monthlyChatLimit: 50,
+        monthlyChatCount: 5
+      });
+
+      const res = await request(app)
+        .get('/api/me')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(200);
+      expect(res.body.handle).toBe('drsmith');
+      expect(res.body.displayName).toBe('Dr. Smith');
+    });
+
+    it('should reject unauthenticated requests', async () => {
+      const res = await request(app).get('/api/me');
+      expect(res.status).toBe(401);
+    });
+
+    it('should return 404 for non-existent provider', async () => {
+      admin.__reset();
+      const res = await request(app)
+        .get('/api/me')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('POST /api/waitlist', () => {
+    it('should register a new waitlist entry', async () => {
+      const res = await request(app)
+        .post('/api/waitlist')
+        .send({ email: 'newdoc@example.com', name: 'Dr. New', specialty: 'Cardiology' });
+
+      expect(res.status).toBe(200);
+      expect(res.body.status).toBe('registered');
+    });
+
+    it('should deduplicate by email', async () => {
+      admin.__seed('waitlist', 'existing', {
+        email: 'existing@example.com',
+        approved: false
+      });
+
+      const res = await request(app)
+        .post('/api/waitlist')
+        .send({ email: 'existing@example.com' });
+
+      expect(res.status).toBe(200);
+      expect(res.body.status).toBe('already_registered');
+    });
+
+    it('should reject invalid email', async () => {
+      const res = await request(app)
+        .post('/api/waitlist')
+        .send({ email: 'not-an-email' });
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject missing email', async () => {
+      const res = await request(app)
+        .post('/api/waitlist')
+        .send({ name: 'Dr. Nobody' });
+
+      expect(res.status).toBe(400);
+    });
+  });
+});

package/tests/integration/api-doctor-drafts.test.js

@@ -0,0 +1,236 @@
+process.env.NODE_ENV = 'test';
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+jest.mock('stripe', () => jest.fn().mockReturnValue({}));
+jest.mock('openai', () => jest.fn().mockImplementation(() => ({
+  chat: { completions: { create: jest.fn().mockResolvedValue({ choices: [{ message: { content: '{"response":"Draft reply"}' } }] }) } }
+})));
+jest.mock('@google/generative-ai', () => ({
+  GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
+    getGenerativeModel: () => ({
+      generateContent: jest.fn().mockResolvedValue({ response: { text: () => 'mock' } })
+    })
+  }))
+}));
+jest.mock('../../functions/src/stripe-config', () => ({ stripe: {} }));
+jest.mock('../../functions/src/payment', () => ({
+  createConnectAccount: jest.fn(),
+  createAccountLink: jest.fn(),
+  refreshAccountStatus: jest.fn(),
+  setProviderPricing: jest.fn(),
+  createCheckoutSession: jest.fn(),
+  createPaymentIntent: jest.fn(),
+  createSubscription: jest.fn(),
+  cancelSubscription: jest.fn(),
+  checkPaymentAccess: jest.fn(),
+  getRevenueAnalytics: jest.fn(),
+  handleStripeWebhook: jest.fn()
+}));
+
+process.env.DEEPSEEK_API_KEY = 'test-key';
+process.env.GEMINI_API_KEY = 'test-key';
+
+const request = require('supertest');
+const admin = require('firebase-admin');
+
+admin.auth().verifyIdToken = jest.fn(async (token) => {
+  if (token === 'valid-doctor-token') return { uid: 'doctor-uid-1', email: 'doc@test.com' };
+  throw new Error('Invalid token');
+});
+
+const app = require('../../server');
+
+describe('Doctor Draft & Notification Preferences API', () => {
+  beforeEach(() => {
+    admin.__reset();
+    admin.__seed('providers', 'doctor-uid-1', {
+      ownerUid: 'doctor-uid-1',
+      handle: 'drsmith',
+      displayName: 'Dr. Smith',
+      specialty: 'General',
+      status: 'published',
+      enabledTopics: ['general_health_info'],
+      plan: 'free',
+      monthlyChatLimit: 50,
+      monthlyChatCount: 5,
+      draftsAccepted: 0,
+      draftsEdited: 0,
+      draftsRejected: 0
+    });
+  });
+
+  describe('POST /api/doctor/draft/accept', () => {
+    it('should accept an AI draft and send as doctor message', async () => {
+      admin.__seed('threads', 'thread-draft-1', {
+        doctorId: 'doctor-uid-1',
+        aiDraftResponse: 'Here is the AI suggestion',
+        aiDraftStatus: 'pending'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-draft-1' });
+
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+
+      const thread = admin.__getAll('threads')['thread-draft-1'];
+      expect(thread.aiDraftStatus).toBe('accepted');
+    });
+
+    it('should accept with edits and mark as edited', async () => {
+      admin.__seed('threads', 'thread-draft-2', {
+        doctorId: 'doctor-uid-1',
+        aiDraftResponse: 'Original draft',
+        aiDraftStatus: 'pending'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-draft-2', editedMessage: 'Edited version' });
+
+      expect(res.status).toBe(200);
+
+      const thread = admin.__getAll('threads')['thread-draft-2'];
+      expect(thread.aiDraftStatus).toBe('edited');
+    });
+
+    it('should reject when no draft is available', async () => {
+      admin.__seed('threads', 'thread-no-draft', {
+        doctorId: 'doctor-uid-1'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-no-draft' });
+
+      expect(res.status).toBe(400);
+      expect(res.body.error).toMatch(/No draft/);
+    });
+
+    it('should reject missing threadId', async () => {
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({});
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject access to other doctor threads', async () => {
+      admin.__seed('threads', 'thread-other', {
+        doctorId: 'other-doctor',
+        aiDraftResponse: 'Draft text',
+        aiDraftStatus: 'pending'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-other' });
+
+      expect(res.status).toBe(404);
+    });
+
+    it('should reject unauthenticated requests', async () => {
+      const res = await request(app)
+        .post('/api/doctor/draft/accept')
+        .send({ threadId: 'thread-1' });
+
+      expect(res.status).toBe(401);
+    });
+  });
+
+  describe('POST /api/doctor/draft/regenerate', () => {
+    it('should regenerate a draft for a thread', async () => {
+      admin.__seed('threads', 'thread-regen', {
+        doctorId: 'doctor-uid-1',
+        aiDraftResponse: 'Old draft',
+        aiDraftStatus: 'rejected',
+        currentTopic: 'general_health_info'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/regenerate')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-regen' });
+
+      expect(res.status).toBe(200);
+    });
+
+    it('should reject missing threadId', async () => {
+      const res = await request(app)
+        .post('/api/doctor/draft/regenerate')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({});
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should reject access to other doctor threads', async () => {
+      admin.__seed('threads', 'thread-other-regen', {
+        doctorId: 'other-doctor'
+      });
+
+      const res = await request(app)
+        .post('/api/doctor/draft/regenerate')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ threadId: 'thread-other-regen' });
+
+      expect(res.status).toBe(404);
+    });
+  });
+
+  describe('POST /api/doctor/notifications/preferences', () => {
+    it('should update notification preferences', async () => {
+      const res = await request(app)
+        .post('/api/doctor/notifications/preferences')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({
+          escalationNotify: true,
+          unreadNotify: false,
+          dailyDigestEnabled: true,
+          unreadDelayMinutes: 15
+        });
+
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+      expect(res.body.preferences.escalationNotify).toBe(true);
+      expect(res.body.preferences.unreadNotify).toBe(false);
+      expect(res.body.preferences.dailyDigestEnabled).toBe(true);
+      expect(res.body.preferences.unreadDelayMinutes).toBe(15);
+    });
+
+    it('should clamp unreadDelayMinutes to 1-60 range', async () => {
+      const res = await request(app)
+        .post('/api/doctor/notifications/preferences')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ unreadDelayMinutes: 0 });
+
+      expect(res.status).toBe(200);
+      expect(res.body.preferences.unreadDelayMinutes).toBe(1);
+    });
+
+    it('should ignore non-boolean values for boolean fields', async () => {
+      const res = await request(app)
+        .post('/api/doctor/notifications/preferences')
+        .set('Authorization', 'Bearer valid-doctor-token')
+        .send({ escalationNotify: 'yes', pushEnabled: 42 });
+
+      expect(res.status).toBe(200);
+      expect(res.body.preferences.escalationNotify).toBeUndefined();
+      expect(res.body.preferences.pushEnabled).toBeUndefined();
+    });
+
+    it('should reject unauthenticated requests', async () => {
+      const res = await request(app)
+        .post('/api/doctor/notifications/preferences')
+        .send({ escalationNotify: true });
+
+      expect(res.status).toBe(401);
+    });
+  });
+});