evaldoc 1.0.0

package/tests/unit/feedback.test.js

@@ -0,0 +1,148 @@
+/**
+ * Unit tests for the doctor feedback module
+ */
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+const admin = require('firebase-admin');
+const { captureDoctorExample, retrieveRelevantExamples, getFeedbackStats } = require('../../functions/src/feedback');
+
+describe('Feedback Module', () => {
+  beforeEach(() => {
+    admin.__reset();
+  });
+
+  describe('captureDoctorExample', () => {
+    it('should store a doctor example in Firestore', async () => {
+      // Seed a thread so the update doesn't fail
+      admin.__seed('threads', 'thread-1', { doctorId: 'doc-1' });
+
+      const result = await captureDoctorExample({
+        doctorId: 'doc-1',
+        threadId: 'thread-1',
+        topic: 'general_health_info',
+        patientMessage: 'I have a headache',
+        doctorResponse: 'Try resting and staying hydrated.',
+        wasAiDraft: false,
+        aiDraftOriginal: null
+      });
+
+      expect(result.id).toBeDefined();
+      expect(result.patientMessage).toBe('I have a headache');
+      expect(result.doctorResponse).toBe('Try resting and staying hydrated.');
+      expect(result.wasAiDraft).toBe(false);
+      expect(result.editDistance).toBeNull();
+    });
+
+    it('should calculate edit distance when AI draft was edited', async () => {
+      admin.__seed('threads', 'thread-2', { doctorId: 'doc-1' });
+
+      const result = await captureDoctorExample({
+        doctorId: 'doc-1',
+        threadId: 'thread-2',
+        topic: 'general_health_info',
+        patientMessage: 'I have a headache',
+        doctorResponse: 'I recommend rest, hydration, and ibuprofen.',
+        wasAiDraft: true,
+        aiDraftOriginal: 'Based on your symptoms, rest and hydration are recommended.'
+      });
+
+      expect(result.wasAiDraft).toBe(true);
+      expect(result.editDistance).toBeDefined();
+      expect(typeof result.editDistance).toBe('number');
+      expect(result.editDistance).toBeGreaterThan(0);
+      expect(result.editDistance).toBeLessThanOrEqual(1);
+    });
+
+    it('should truncate long messages', async () => {
+      admin.__seed('threads', 'thread-3', { doctorId: 'doc-1' });
+
+      const longMessage = 'x'.repeat(2000);
+      const result = await captureDoctorExample({
+        doctorId: 'doc-1',
+        threadId: 'thread-3',
+        topic: 'general_health_info',
+        patientMessage: longMessage,
+        doctorResponse: 'Short response',
+        wasAiDraft: false,
+        aiDraftOriginal: null
+      });
+
+      expect(result.patientMessage.length).toBeLessThanOrEqual(500);
+    });
+  });
+
+  describe('retrieveRelevantExamples', () => {
+    it('should return empty array when no examples exist', async () => {
+      const result = await retrieveRelevantExamples({
+        doctorId: 'doc-1',
+        topic: 'general_health_info',
+        limit: 3
+      });
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return examples from Firestore', async () => {
+      // Seed some examples
+      const col = 'providers/doc-1/doctorExamples';
+      admin.__seed(col, 'ex-1', {
+        topic: 'general_health_info',
+        patientMessage: 'headache',
+        doctorResponse: 'rest',
+        createdAt: { _seconds: 1000 }
+      });
+      admin.__seed(col, 'ex-2', {
+        topic: 'general_health_info',
+        patientMessage: 'cough',
+        doctorResponse: 'hydrate',
+        createdAt: { _seconds: 2000 }
+      });
+
+      const result = await retrieveRelevantExamples({
+        doctorId: 'doc-1',
+        topic: 'general_health_info',
+        limit: 3
+      });
+
+      expect(result.length).toBe(2);
+    });
+  });
+
+  describe('getFeedbackStats', () => {
+    it('should return zero stats when no examples exist', async () => {
+      const stats = await getFeedbackStats({ doctorId: 'doc-1' });
+
+      expect(stats.totalExamples).toBe(0);
+      expect(stats.aiDraftBased).toBe(0);
+      expect(stats.manualResponses).toBe(0);
+      expect(stats.avgEditDistance).toBeNull();
+    });
+
+    it('should compute correct stats from examples', async () => {
+      const col = 'providers/doc-1/doctorExamples';
+      admin.__seed(col, 'ex-1', {
+        wasAiDraft: true,
+        editDistance: 0.3,
+        createdAt: { _seconds: 1000 }
+      });
+      admin.__seed(col, 'ex-2', {
+        wasAiDraft: true,
+        editDistance: 0.5,
+        createdAt: { _seconds: 2000 }
+      });
+      admin.__seed(col, 'ex-3', {
+        wasAiDraft: false,
+        editDistance: null,
+        createdAt: { _seconds: 3000 }
+      });
+
+      const stats = await getFeedbackStats({ doctorId: 'doc-1' });
+
+      expect(stats.totalExamples).toBe(3);
+      expect(stats.aiDraftBased).toBe(2);
+      expect(stats.manualResponses).toBe(1);
+      expect(stats.avgEditDistance).toBe(0.4);
+    });
+  });
+});

package/tests/unit/i18n.test.js

@@ -0,0 +1,229 @@
+/**
+ * Unit tests for the i18n localization module.
+ *
+ * Verifies:
+ *   - t() returns correct translation per supported locale
+ *   - t() falls back to English for unknown locale / unknown key
+ *   - normalizeLocale handles region tags, casing, and unsupported input
+ *   - SUPPORTED_LOCALES is exactly the 6 expected locales
+ *   - Every MESSAGES key exists in every locale (no missing translations)
+ */
+
+const {
+  SUPPORTED_LOCALES,
+  MESSAGES,
+  normalizeLocale,
+  t,
+  DEFAULT_LOCALE
+} = require('../../functions/src/i18n');
+
+const EXPECTED_LOCALES = ['en', 'es', 'fr', 'de', 'pt', 'ar'];
+const KEYS = ['disclaimer_footer', 'refusal', 'escalation', 'emergency_banner'];
+
+describe('SUPPORTED_LOCALES', () => {
+  test('contains exactly the 6 expected locales', () => {
+    expect(SUPPORTED_LOCALES).toEqual(EXPECTED_LOCALES);
+  });
+
+  test('has length 6', () => {
+    expect(SUPPORTED_LOCALES).toHaveLength(6);
+  });
+
+  test('includes Arabic', () => {
+    expect(SUPPORTED_LOCALES).toContain('ar');
+  });
+
+  test('default locale is a supported locale', () => {
+    expect(SUPPORTED_LOCALES).toContain(DEFAULT_LOCALE);
+    expect(DEFAULT_LOCALE).toBe('en');
+  });
+});
+
+describe('t() returns correct translation per locale', () => {
+  test('English disclaimer_footer', () => {
+    expect(t('disclaimer_footer', 'en')).toBe(
+      'This is general information, not medical advice. Consult a licensed clinician.'
+    );
+  });
+
+  test('English refusal', () => {
+    expect(t('refusal', 'en')).toBe(
+      "I can't help with that. Please consult a licensed clinician for personalized medical advice."
+    );
+  });
+
+  test('English escalation', () => {
+    expect(t('escalation', 'en')).toBe(
+      'This may be urgent. Please seek emergency care or contact your local emergency number immediately.'
+    );
+  });
+
+  test('English emergency_banner', () => {
+    expect(t('emergency_banner', 'en')).toBe(
+      'If this is an emergency, call your local emergency number now.'
+    );
+  });
+
+  test('Spanish refusal matches table', () => {
+    expect(t('refusal', 'es')).toBe(MESSAGES.es.refusal);
+    expect(t('refusal', 'es')).not.toBe(MESSAGES.en.refusal);
+  });
+
+  test('French escalation matches table', () => {
+    expect(t('escalation', 'fr')).toBe(MESSAGES.fr.escalation);
+    expect(t('escalation', 'fr')).not.toBe(MESSAGES.en.escalation);
+  });
+
+  test('German disclaimer_footer matches table', () => {
+    expect(t('disclaimer_footer', 'de')).toBe(MESSAGES.de.disclaimer_footer);
+    expect(t('disclaimer_footer', 'de')).not.toBe(MESSAGES.en.disclaimer_footer);
+  });
+
+  test('Portuguese emergency_banner matches table', () => {
+    expect(t('emergency_banner', 'pt')).toBe(MESSAGES.pt.emergency_banner);
+    expect(t('emergency_banner', 'pt')).not.toBe(MESSAGES.en.emergency_banner);
+  });
+
+  test('Arabic refusal matches table and is non-empty', () => {
+    expect(t('refusal', 'ar')).toBe(MESSAGES.ar.refusal);
+    expect(t('refusal', 'ar').length).toBeGreaterThan(0);
+    expect(t('refusal', 'ar')).not.toBe(MESSAGES.en.refusal);
+  });
+
+  test('returns a translation for every key in every supported locale', () => {
+    for (const locale of EXPECTED_LOCALES) {
+      for (const key of KEYS) {
+        expect(t(key, locale)).toBe(MESSAGES[locale][key]);
+      }
+    }
+  });
+
+  test('t() applies normalization to the locale argument', () => {
+    expect(t('refusal', 'es-ES')).toBe(MESSAGES.es.refusal);
+    expect(t('refusal', 'FR')).toBe(MESSAGES.fr.refusal);
+  });
+});
+
+describe('t() fallback behavior', () => {
+  test('falls back to English for an unknown locale', () => {
+    expect(t('refusal', 'zz')).toBe(MESSAGES.en.refusal);
+  });
+
+  test('falls back to English for null locale', () => {
+    expect(t('escalation', null)).toBe(MESSAGES.en.escalation);
+  });
+
+  test('falls back to English for undefined locale', () => {
+    expect(t('escalation', undefined)).toBe(MESSAGES.en.escalation);
+  });
+
+  test('falls back to English for an unknown key in a known locale', () => {
+    // Unknown key does not exist anywhere -> empty string.
+    expect(t('does_not_exist', 'es')).toBe('');
+  });
+
+  test('returns empty string for an unknown key with English locale', () => {
+    expect(t('totally_missing', 'en')).toBe('');
+  });
+
+  test('uses English when a key is missing only in a non-English locale', () => {
+    // Simulate a partially-translated locale by temporarily deleting a key.
+    const saved = MESSAGES.es.refusal;
+    delete MESSAGES.es.refusal;
+    try {
+      expect(t('refusal', 'es')).toBe(MESSAGES.en.refusal);
+    } finally {
+      MESSAGES.es.refusal = saved;
+    }
+  });
+});
+
+describe('normalizeLocale()', () => {
+  test("'en-US' -> 'en'", () => {
+    expect(normalizeLocale('en-US')).toBe('en');
+  });
+
+  test("'ES' -> 'es'", () => {
+    expect(normalizeLocale('ES')).toBe('es');
+  });
+
+  test("'pt_BR' -> 'pt' (underscore separator)", () => {
+    expect(normalizeLocale('pt_BR')).toBe('pt');
+  });
+
+  test("'fr-CA' -> 'fr'", () => {
+    expect(normalizeLocale('fr-CA')).toBe('fr');
+  });
+
+  test("'AR' -> 'ar'", () => {
+    expect(normalizeLocale('AR')).toBe('ar');
+  });
+
+  test("unsupported 'xx' -> 'en'", () => {
+    expect(normalizeLocale('xx')).toBe('en');
+  });
+
+  test('null -> en', () => {
+    expect(normalizeLocale(null)).toBe('en');
+  });
+
+  test('undefined -> en', () => {
+    expect(normalizeLocale(undefined)).toBe('en');
+  });
+
+  test('empty string -> en', () => {
+    expect(normalizeLocale('')).toBe('en');
+  });
+
+  test('whitespace-only string -> en', () => {
+    expect(normalizeLocale('   ')).toBe('en');
+  });
+
+  test('non-string input -> en', () => {
+    expect(normalizeLocale(42)).toBe('en');
+    expect(normalizeLocale({})).toBe('en');
+  });
+
+  test('already-normalized locales are returned unchanged', () => {
+    for (const locale of EXPECTED_LOCALES) {
+      expect(normalizeLocale(locale)).toBe(locale);
+    }
+  });
+
+  test('mixed-case with region -> base locale', () => {
+    expect(normalizeLocale('De-de')).toBe('de');
+  });
+});
+
+describe('MESSAGES integrity', () => {
+  test('has an entry for every supported locale', () => {
+    for (const locale of EXPECTED_LOCALES) {
+      expect(MESSAGES).toHaveProperty(locale);
+    }
+  });
+
+  test('every key exists in every locale (no missing translations)', () => {
+    for (const locale of EXPECTED_LOCALES) {
+      for (const key of KEYS) {
+        expect(MESSAGES[locale]).toHaveProperty(key);
+        expect(typeof MESSAGES[locale][key]).toBe('string');
+        expect(MESSAGES[locale][key].trim().length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test('every locale has the same set of keys as English', () => {
+    const enKeys = Object.keys(MESSAGES.en).sort();
+    for (const locale of EXPECTED_LOCALES) {
+      expect(Object.keys(MESSAGES[locale]).sort()).toEqual(enKeys);
+    }
+  });
+
+  test('non-English translations differ from English', () => {
+    for (const locale of EXPECTED_LOCALES.filter((l) => l !== 'en')) {
+      for (const key of KEYS) {
+        expect(MESSAGES[locale][key]).not.toBe(MESSAGES.en[key]);
+      }
+    }
+  });
+});

package/tests/unit/llm-retry.test.js

@@ -0,0 +1,122 @@
+const { withRetry } = require('../../functions/src/llm');
+
+describe('withRetry', () => {
+  it('should succeed on first attempt', async () => {
+    const fn = jest.fn().mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry on 429 rate limit', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ status: 429, message: 'rate limited' })
+      .mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should retry on 500 server error', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ status: 500, message: 'server error' })
+      .mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should retry on 502 gateway error', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ status: 502, message: 'bad gateway' })
+      .mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should retry on network errors', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ code: 'ECONNRESET', message: 'connection reset' })
+      .mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should retry on ETIMEDOUT', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ code: 'ETIMEDOUT', message: 'timeout' })
+      .mockResolvedValue('ok');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('ok');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should NOT retry on 400 bad request', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue({ status: 400, message: 'bad request' });
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 1 }))
+      .rejects.toMatchObject({ status: 400 });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should NOT retry on 401 unauthorized', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue({ status: 401, message: 'unauthorized' });
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 1 }))
+      .rejects.toMatchObject({ status: 401 });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should NOT retry on 403 forbidden', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue({ status: 403, message: 'forbidden' });
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 1 }))
+      .rejects.toMatchObject({ status: 403 });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should exhaust retries and throw on persistent transient error', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue({ status: 503, message: 'service unavailable' });
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 1 }))
+      .rejects.toMatchObject({ status: 503 });
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should succeed on last retry attempt', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ status: 500, message: 'fail 1' })
+      .mockRejectedValueOnce({ status: 502, message: 'fail 2' })
+      .mockResolvedValue('finally');
+    const result = await withRetry(fn, { maxRetries: 2, baseDelayMs: 1 });
+    expect(result).toBe('finally');
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('should use maxRetries=0 for no retries', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue({ status: 500, message: 'fail' });
+    await expect(withRetry(fn, { maxRetries: 0, baseDelayMs: 1 }))
+      .rejects.toMatchObject({ status: 500 });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle errors without status code as non-transient', async () => {
+    const fn = jest.fn()
+      .mockRejectedValue(new Error('unknown error'));
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 1 }))
+      .rejects.toThrow('unknown error');
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle ECONNREFUSED as transient', async () => {
+    const fn = jest.fn()
+      .mockRejectedValueOnce({ code: 'ECONNREFUSED', message: 'refused' })
+      .mockResolvedValue('connected');
+    const result = await withRetry(fn, { maxRetries: 1, baseDelayMs: 1 });
+    expect(result).toBe('connected');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/unit/notifications.test.js

@@ -0,0 +1,155 @@
+/**
+ * Unit tests for the notification system
+ */
+
+jest.mock('firebase-admin', () => require('../mocks/firebase-admin'));
+
+const admin = require('firebase-admin');
+const {
+  NOTIFICATION_TYPES,
+  createNotification,
+  notifyEscalation,
+  notifyDraftReady,
+  getNotifications,
+  getUnreadCount,
+  markNotificationRead,
+  markAllNotificationsRead
+} = require('../../functions/src/notifications');
+
+describe('Notifications Module', () => {
+  beforeEach(() => {
+    admin.__reset();
+  });
+
+  describe('NOTIFICATION_TYPES', () => {
+    it('should have all expected types', () => {
+      expect(NOTIFICATION_TYPES.ESCALATION).toBe('escalation');
+      expect(NOTIFICATION_TYPES.UNREAD).toBe('unread_messages');
+      expect(NOTIFICATION_TYPES.DAILY_DIGEST).toBe('daily_digest');
+      expect(NOTIFICATION_TYPES.NEW_THREAD).toBe('new_thread');
+      expect(NOTIFICATION_TYPES.DRAFT_READY).toBe('draft_ready');
+    });
+  });
+
+  describe('createNotification', () => {
+    it('should create a notification in Firestore', async () => {
+      const result = await createNotification({
+        doctorId: 'doc-1',
+        type: 'escalation',
+        title: 'Urgent',
+        body: 'Patient needs help',
+        threadId: 'thread-1'
+      });
+
+      expect(result.id).toBeDefined();
+      expect(result.doctorId).toBe('doc-1');
+      expect(result.type).toBe('escalation');
+      expect(result.read).toBe(false);
+    });
+  });
+
+  describe('notifyEscalation', () => {
+    it('should create an escalation notification', async () => {
+      // Seed thread and provider for the update calls
+      admin.__seed('threads', 'thread-1', { doctorId: 'doc-1' });
+      admin.__seed('providers', 'doc-1', { email: 'doc@test.com' });
+
+      await notifyEscalation({
+        doctorId: 'doc-1',
+        threadId: 'thread-1',
+        patientName: 'Jane',
+        reason: 'Chest pain reported'
+      });
+
+      const notifications = admin.__getAll('notifications');
+      const notifIds = Object.keys(notifications);
+      expect(notifIds.length).toBe(1);
+
+      const notif = notifications[notifIds[0]];
+      expect(notif.type).toBe('escalation');
+      expect(notif.title).toMatch(/Urgent/i);
+      expect(notif.body).toContain('Jane');
+    });
+  });
+
+  describe('notifyDraftReady', () => {
+    it('should create a draft-ready notification', async () => {
+      await notifyDraftReady({
+        doctorId: 'doc-1',
+        threadId: 'thread-1',
+        patientName: 'Bob'
+      });
+
+      const notifications = admin.__getAll('notifications');
+      const notif = Object.values(notifications)[0];
+      expect(notif.type).toBe('draft_ready');
+      expect(notif.body).toContain('Bob');
+    });
+  });
+
+  describe('getNotifications', () => {
+    it('should return notifications sorted by creation time', async () => {
+      admin.__seed('notifications', 'n1', {
+        doctorId: 'doc-1', type: 'escalation', read: false, createdAt: { _seconds: 1000 }
+      });
+      admin.__seed('notifications', 'n2', {
+        doctorId: 'doc-1', type: 'draft_ready', read: false, createdAt: { _seconds: 2000 }
+      });
+      admin.__seed('notifications', 'n3', {
+        doctorId: 'doc-2', type: 'escalation', read: false, createdAt: { _seconds: 3000 }
+      });
+
+      const result = await getNotifications({ doctorId: 'doc-1', limit: 10 });
+      expect(result.length).toBe(2);
+      // Should be sorted desc by createdAt
+      expect(result[0].id).toBe('n2');
+      expect(result[1].id).toBe('n1');
+    });
+  });
+
+  describe('getUnreadCount', () => {
+    it('should count only unread notifications for the doctor', async () => {
+      admin.__seed('notifications', 'n1', { doctorId: 'doc-1', read: false });
+      admin.__seed('notifications', 'n2', { doctorId: 'doc-1', read: true });
+      admin.__seed('notifications', 'n3', { doctorId: 'doc-1', read: false });
+      admin.__seed('notifications', 'n4', { doctorId: 'doc-2', read: false });
+
+      const count = await getUnreadCount({ doctorId: 'doc-1' });
+      expect(count).toBe(2);
+    });
+  });
+
+  describe('markNotificationRead', () => {
+    it('should mark a notification as read', async () => {
+      admin.__seed('notifications', 'n1', { doctorId: 'doc-1', read: false });
+
+      const result = await markNotificationRead({ notificationId: 'n1', doctorId: 'doc-1' });
+      expect(result).toBe(true);
+
+      const updated = admin.__getAll('notifications')['n1'];
+      expect(updated.read).toBe(true);
+    });
+
+    it('should reject marking another doctors notification', async () => {
+      admin.__seed('notifications', 'n1', { doctorId: 'doc-2', read: false });
+
+      const result = await markNotificationRead({ notificationId: 'n1', doctorId: 'doc-1' });
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('markAllNotificationsRead', () => {
+    it('should mark all unread notifications as read', async () => {
+      admin.__seed('notifications', 'n1', { doctorId: 'doc-1', read: false });
+      admin.__seed('notifications', 'n2', { doctorId: 'doc-1', read: false });
+      admin.__seed('notifications', 'n3', { doctorId: 'doc-1', read: true });
+
+      const count = await markAllNotificationsRead({ doctorId: 'doc-1' });
+      expect(count).toBe(2);
+
+      const all = admin.__getAll('notifications');
+      expect(all['n1'].read).toBe(true);
+      expect(all['n2'].read).toBe(true);
+    });
+  });
+});