evaldoc 1.0.0

package/tests/integration/api-webhook-deletion.test.js

@@ -0,0 +1,231 @@
+process.env.NODE_ENV = 'test';
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+const mockStripe = {
+  webhooks: {
+    constructEvent: jest.fn()
+  }
+};
+
+jest.mock('stripe', () => jest.fn().mockReturnValue(mockStripe));
+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: mockStripe }));
+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';
+process.env.STRIPE_WEBHOOK_SECRET = 'whsec_test_secret';
+
+const request = require('supertest');
+const admin = require('firebase-admin');
+const { handleStripeWebhook } = require('../../functions/src/payment');
+
+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('Webhook, Conversation Deletion & Feedback Stats API', () => {
+  beforeEach(() => {
+    admin.__reset();
+    jest.clearAllMocks();
+
+    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
+    });
+  });
+
+  // ============================================
+  // POST /api/payment/webhook
+  // ============================================
+
+  describe('POST /api/payment/webhook', () => {
+    it('should process a valid webhook event and call handleStripeWebhook', async () => {
+      const fakeEvent = { id: 'evt_123', type: 'payment_intent.succeeded', data: {} };
+      mockStripe.webhooks.constructEvent.mockReturnValue(fakeEvent);
+      handleStripeWebhook.mockResolvedValue(undefined);
+
+      const res = await request(app)
+        .post('/api/payment/webhook')
+        .set('stripe-signature', 'sig_valid')
+        .set('Content-Type', 'application/json')
+        .send(JSON.stringify({ id: 'evt_123' }));
+
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual({ received: true });
+      expect(mockStripe.webhooks.constructEvent).toHaveBeenCalled();
+      expect(handleStripeWebhook).toHaveBeenCalledWith(fakeEvent);
+    });
+
+    it('should return 400 when signature verification fails', async () => {
+      mockStripe.webhooks.constructEvent.mockImplementation(() => {
+        throw new Error('Invalid signature');
+      });
+
+      const res = await request(app)
+        .post('/api/payment/webhook')
+        .set('stripe-signature', 'sig_invalid')
+        .set('Content-Type', 'application/json')
+        .send(JSON.stringify({ id: 'evt_bad' }));
+
+      expect(res.status).toBe(400);
+      expect(res.text).toContain('Webhook Error');
+      expect(handleStripeWebhook).not.toHaveBeenCalled();
+    });
+
+    it('should return 200 even when handleStripeWebhook throws', async () => {
+      const fakeEvent = { id: 'evt_456', type: 'invoice.paid', data: {} };
+      mockStripe.webhooks.constructEvent.mockReturnValue(fakeEvent);
+      handleStripeWebhook.mockRejectedValue(new Error('Handler failed'));
+
+      const res = await request(app)
+        .post('/api/payment/webhook')
+        .set('stripe-signature', 'sig_valid')
+        .set('Content-Type', 'application/json')
+        .send(JSON.stringify({ id: 'evt_456' }));
+
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual({ received: true });
+    });
+  });
+
+  // ============================================
+  // DELETE /api/conversations/:threadId
+  // ============================================
+
+  describe('DELETE /api/conversations/:threadId', () => {
+    it('should delete a thread owned by the authenticated doctor', async () => {
+      admin.__seed('threads', 'thread-del-1', {
+        doctorId: 'doctor-uid-1',
+        subject: 'Test conversation'
+      });
+
+      const res = await request(app)
+        .delete('/api/conversations/thread-del-1')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+
+      const threads = admin.__getAll('threads');
+      expect(threads['thread-del-1']).toBeUndefined();
+    });
+
+    it('should reject deletion of threads owned by other doctors (403)', async () => {
+      admin.__seed('threads', 'thread-other-doc', {
+        doctorId: 'other-doctor-uid',
+        subject: 'Other doctor conversation'
+      });
+
+      const res = await request(app)
+        .delete('/api/conversations/thread-other-doc')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(403);
+      expect(res.body.error).toContain('Not authorized');
+    });
+
+    it('should return 404 when thread does not exist', async () => {
+      const res = await request(app)
+        .delete('/api/conversations/nonexistent-thread')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(404);
+      expect(res.body.error).toContain('Conversation not found');
+    });
+
+    it('should reject unauthenticated requests (401)', async () => {
+      admin.__seed('threads', 'thread-del-2', {
+        doctorId: 'doctor-uid-1',
+        subject: 'Test conversation'
+      });
+
+      const res = await request(app)
+        .delete('/api/conversations/thread-del-2');
+
+      expect(res.status).toBe(401);
+    });
+  });
+
+  // ============================================
+  // GET /api/doctor/feedback/stats
+  // ============================================
+
+  describe('GET /api/doctor/feedback/stats', () => {
+    it('should return feedback stats for authenticated doctor', async () => {
+      admin.__seed('providers/doctor-uid-1/doctorExamples', 'ex-1', {
+        wasAiDraft: true,
+        editDistance: 0.3,
+        createdAt: { _seconds: 1000 }
+      });
+      admin.__seed('providers/doctor-uid-1/doctorExamples', 'ex-2', {
+        wasAiDraft: false,
+        editDistance: null,
+        createdAt: { _seconds: 900 }
+      });
+
+      const res = await request(app)
+        .get('/api/doctor/feedback/stats')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(200);
+      expect(res.body.totalExamples).toBe(2);
+      expect(res.body.aiDraftBased).toBe(1);
+      expect(res.body.manualResponses).toBe(1);
+      expect(res.body.avgEditDistance).toBe(0.3);
+    });
+
+    it('should return zero stats when no examples exist', async () => {
+      const res = await request(app)
+        .get('/api/doctor/feedback/stats')
+        .set('Authorization', 'Bearer valid-doctor-token');
+
+      expect(res.status).toBe(200);
+      expect(res.body.totalExamples).toBe(0);
+      expect(res.body.aiDraftBased).toBe(0);
+      expect(res.body.manualResponses).toBe(0);
+      expect(res.body.avgEditDistance).toBeNull();
+    });
+
+    it('should reject unauthenticated requests', async () => {
+      const res = await request(app)
+        .get('/api/doctor/feedback/stats');
+
+      expect(res.status).toBe(401);
+    });
+  });
+});

package/tests/mocks/firebase-admin.js

@@ -0,0 +1,220 @@
+/**
+ * Mock firebase-admin for testing.
+ *
+ * Provides an in-memory Firestore mock that supports:
+ *   collection / doc / add / set / get / update / where / orderBy / limit / batch
+ *
+ * Usage:
+ *   jest.mock('firebase-admin', () => require('./mocks/firebase-admin'));
+ *   const admin = require('firebase-admin');
+ *   admin.__collections  // access raw data
+ *   admin.__reset()      // clear all data between tests
+ */
+
+let _collections = {};
+let _autoId = 0;
+
+function reset() {
+  _collections = {};
+  _autoId = 0;
+}
+
+function getCollection(name) {
+  if (!_collections[name]) _collections[name] = {};
+  return _collections[name];
+}
+
+function makeDocRef(collectionName, docId) {
+  return {
+    id: docId,
+    get: async () => {
+      const col = getCollection(collectionName);
+      const data = col[docId];
+      return {
+        exists: !!data,
+        id: docId,
+        data: () => data ? { ...data } : undefined,
+        ref: makeDocRef(collectionName, docId)
+      };
+    },
+    set: async (data, options) => {
+      const col = getCollection(collectionName);
+      if (options && options.merge) {
+        col[docId] = { ...(col[docId] || {}), ...data };
+      } else {
+        col[docId] = { ...data };
+      }
+    },
+    update: async (data) => {
+      const col = getCollection(collectionName);
+      if (!col[docId]) throw new Error(`Document ${collectionName}/${docId} not found`);
+      col[docId] = { ...col[docId], ...data };
+    },
+    delete: async () => {
+      const col = getCollection(collectionName);
+      delete col[docId];
+    },
+    collection: (subName) => makeCollectionRef(`${collectionName}/${docId}/${subName}`)
+  };
+}
+
+function makeQuerySnapshot(collectionName, filterFns) {
+  const col = getCollection(collectionName);
+  let docs = Object.entries(col).map(([id, data]) => ({
+    id,
+    data: () => ({ ...data }),
+    ref: makeDocRef(collectionName, id)
+  }));
+
+  for (const fn of filterFns) {
+    docs = fn(docs);
+  }
+
+  return {
+    docs,
+    empty: docs.length === 0,
+    size: docs.length,
+    forEach: (cb) => docs.forEach(cb)
+  };
+}
+
+function makeCollectionRef(name) {
+  let _filters = [];
+
+  const ref = {
+    add: async (data) => {
+      const col = getCollection(name);
+      const id = `auto_${++_autoId}`;
+      col[id] = { ...data };
+      return { id, ...makeDocRef(name, id) };
+    },
+    doc: (id) => makeDocRef(name, id),
+    where: (field, op, value) => {
+      _filters.push((docs) => docs.filter(d => {
+        const val = d.data()[field];
+        switch (op) {
+          case '==': return val === value;
+          case '!=': return val !== value;
+          case '>': return val > value;
+          case '>=': return val >= value;
+          case '<': return val < value;
+          case '<=': return val <= value;
+          case 'in': return Array.isArray(value) && value.includes(val);
+          default: return true;
+        }
+      }));
+      return ref;
+    },
+    orderBy: (field, direction) => {
+      _filters.push((docs) => {
+        return [...docs].sort((a, b) => {
+          let aVal = a.data()[field];
+          let bVal = b.data()[field];
+          // Handle Firestore timestamp objects { _seconds: N }
+          if (aVal && typeof aVal === 'object' && aVal._seconds != null) aVal = aVal._seconds;
+          if (bVal && typeof bVal === 'object' && bVal._seconds != null) bVal = bVal._seconds;
+          if (aVal == null && bVal == null) return 0;
+          if (aVal == null) return 1;
+          if (bVal == null) return -1;
+          const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+          return direction === 'desc' ? -cmp : cmp;
+        });
+      });
+      return ref;
+    },
+    select: (...fields) => {
+      return ref;
+    },
+    limit: (n) => {
+      _filters.push((docs) => docs.slice(0, n));
+      return ref;
+    },
+    limitToLast: (n) => {
+      _filters.push((docs) => docs.slice(-n));
+      return ref;
+    },
+    startAfter: (doc) => {
+      _filters.push((docs) => {
+        const idx = docs.findIndex(d => d.id === doc.id);
+        return idx >= 0 ? docs.slice(idx + 1) : docs;
+      });
+      return ref;
+    },
+    get: async () => makeQuerySnapshot(name, _filters)
+  };
+
+  return ref;
+}
+
+function makeBatch() {
+  const ops = [];
+  return {
+    set: (ref, data, options) => ops.push({ type: 'set', ref, data, options }),
+    update: (ref, data) => ops.push({ type: 'update', ref, data }),
+    delete: (ref) => ops.push({ type: 'delete', ref }),
+    commit: async () => {
+      for (const op of ops) {
+        if (op.type === 'set') await op.ref.set(op.data, op.options);
+        else if (op.type === 'update') await op.ref.update(op.data);
+        else if (op.type === 'delete') await op.ref.delete();
+      }
+    }
+  };
+}
+
+// Singleton instances so test overrides persist across calls
+const _firestoreInstance = {
+  collection: (name) => makeCollectionRef(name),
+  batch: () => makeBatch(),
+  runTransaction: async (fn) => {
+    const tx = {
+      get: async (ref) => ref.get(),
+      set: (ref, data) => ref.set(data),
+      update: (ref, data) => ref.update(data)
+    };
+    return fn(tx);
+  }
+};
+
+const _authInstance = {
+  verifyIdToken: jest.fn(async (token) => {
+    if (token === 'valid-token') return { uid: 'test-doctor-uid', email: 'doc@test.com' };
+    if (token === 'patient-token') return { uid: 'test-patient-uid', email: 'patient@test.com' };
+    throw new Error('Invalid token');
+  })
+};
+
+const mockAdmin = {
+  apps: [{ name: '[DEFAULT]' }],
+  initializeApp: jest.fn(),
+  credential: {
+    cert: jest.fn(() => ({})),
+    applicationDefault: jest.fn(() => ({}))
+  },
+  firestore: () => _firestoreInstance,
+  auth: () => _authInstance,
+
+  // Test helpers
+  __collections: _collections,
+  __reset: reset,
+  __seed: (collectionName, docId, data) => {
+    getCollection(collectionName)[docId] = { ...data };
+  },
+  __getAll: (collectionName) => getCollection(collectionName)
+};
+
+// Static FieldValue helpers
+mockAdmin.firestore.FieldValue = {
+  serverTimestamp: () => ({ _seconds: Math.floor(Date.now() / 1000), _nanoseconds: 0 }),
+  increment: (n) => `__increment_${n}`,
+  arrayUnion: (...args) => `__arrayUnion_${args}`,
+  arrayRemove: (...args) => `__arrayRemove_${args}`,
+  delete: () => '__delete'
+};
+
+mockAdmin.firestore.Timestamp = {
+  now: () => ({ _seconds: Math.floor(Date.now() / 1000), _nanoseconds: 0 }),
+  fromDate: (date) => ({ _seconds: Math.floor(date.getTime() / 1000), _nanoseconds: 0 })
+};
+
+module.exports = mockAdmin;

package/tests/unit/analytics.test.js

@@ -0,0 +1,151 @@
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+const admin = require('firebase-admin');
+const { incrementAnalytics, getMonthKey } = require('../../functions/src/analytics');
+
+describe('Analytics Module', () => {
+  beforeEach(() => {
+    admin.__reset();
+  });
+
+  describe('getMonthKey', () => {
+    it('should return YYYY-MM format', () => {
+      const key = getMonthKey(new Date('2026-06-15T00:00:00Z'));
+      expect(key).toBe('2026-06');
+    });
+
+    it('should pad single-digit months', () => {
+      const key = getMonthKey(new Date('2026-03-01T00:00:00Z'));
+      expect(key).toBe('2026-03');
+    });
+  });
+
+  describe('incrementAnalytics', () => {
+    it('should increment chat count in daily analytics', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_123',
+        escalated: false,
+        satisfaction: null,
+        topicKey: 'general_health_info',
+        message: 'What causes headaches?'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const keys = Object.keys(dailyData);
+      expect(keys.length).toBe(1);
+      const entry = dailyData[keys[0]];
+      expect(entry.chatCount).toBe('__increment_1');
+    });
+
+    it('should increment escalation count when escalated', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_456',
+        escalated: true,
+        satisfaction: null,
+        topicKey: 'general_health_info',
+        message: 'I have chest pain'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry.escalationCount).toBe('__increment_1');
+
+      const providerData = admin.__getAll('providers');
+      expect(providerData['test-provider'].totalEscalationCount).toBe('__increment_1');
+    });
+
+    it('should not set escalation count when not escalated', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_789',
+        escalated: false,
+        satisfaction: null,
+        topicKey: 'general_health_info',
+        message: 'Hello'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry.escalationCount).toBeUndefined();
+    });
+
+    it('should increment satisfaction sum and count when provided', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_789',
+        escalated: false,
+        satisfaction: 4,
+        topicKey: 'medication_info_safety',
+        message: 'Thank you'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry.satisfactionSum).toBe('__increment_4');
+      expect(entry.satisfactionCount).toBe('__increment_1');
+    });
+
+    it('should not set satisfaction fields when null', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_null',
+        escalated: false,
+        satisfaction: null,
+        topicKey: null,
+        message: ''
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry.satisfactionSum).toBeUndefined();
+      expect(entry.satisfactionCount).toBeUndefined();
+    });
+
+    it('should track topic counts', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_t',
+        escalated: false,
+        satisfaction: null,
+        topicKey: 'clinic_services_hours',
+        message: 'What are your hours?'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry['topicCounts.clinic_services_hours']).toBe('__increment_1');
+    });
+
+    it('should track session for unique session counting', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_unique',
+        escalated: false,
+        satisfaction: null,
+        topicKey: 'general_health_info',
+        message: 'Hello'
+      });
+
+      const dailyData = admin.__getAll('providers/test-provider/analyticsDaily');
+      const entry = dailyData[Object.keys(dailyData)[0]];
+      expect(entry['sessions.sess_unique']).toBe(true);
+    });
+
+    it('should increment provider-level monthly and total chat counts', async () => {
+      await incrementAnalytics({
+        providerId: 'test-provider',
+        sessionId: 'sess_p',
+        escalated: false,
+        satisfaction: null,
+        topicKey: 'general_health_info',
+        message: 'Test'
+      });
+
+      const providerData = admin.__getAll('providers');
+      expect(providerData['test-provider'].monthlyChatCount).toBe('__increment_1');
+      expect(providerData['test-provider'].totalChatCount).toBe('__increment_1');
+    });
+  });
+});