Tests refactor

packages/api/tests/modules/regimens/regimens.repository.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockFind, mockFindOne, mockFindOneAndUpdate, mockSave } = vi.hoisted(() => ({
+  mockFind: vi.fn(),
+  mockFindOne: vi.fn(),
+  mockFindOneAndUpdate: vi.fn(),
+  mockSave: vi.fn(),
+}));
+
+vi.mock('../../../src/schemas/regimen.schema.js', () => {
+  const chain = () => ({
+    sort: vi.fn().mockReturnThis(),
+    limit: vi.fn().mockReturnThis(),
+    lean: vi.fn().mockReturnThis(),
+    exec: mockFind,
+  });
+
+  const findOneChain = () => ({
+    lean: vi.fn().mockReturnThis(),
+    exec: mockFindOne,
+  });
+
+  const updateChain = () => ({
+    exec: mockFindOneAndUpdate,
+  });
+
+  class FakeModel {
+    data: unknown;
+    constructor(data: unknown) {
+      this.data = data;
+    }
+    save = mockSave;
+    toObject() {
+      return this.data;
+    }
+    static find = vi.fn(() => chain());
+    static findOne = vi.fn(() => findOneChain());
+    static findOneAndUpdate = vi.fn(() => updateChain());
+  }
+
+  return { RegimenModel: FakeModel };
+});
+
+import { RegimensRepository } from '../../../src/modules/regimens/regimens.repository.js';
+
+describe(RegimensRepository.name, () => {
+  let repo: RegimensRepository;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    repo = new RegimensRepository();
+  });
+
+  describe('findByHousehold', () => {
+    it('returns paginated items', async () => {
+      const items = [{ _id: 'reg-1', name: 'Morning' }];
+      mockFind.mockResolvedValue(items);
+
+      const result = await repo.findByHousehold('hh1', 'user-1', { limit: 20 });
+
+      expect(result.data).toEqual(items);
+      expect(result.pagination.hasMore).toBe(false);
+    });
+
+    it('handles cursor-based pagination', async () => {
+      const items = [{ _id: 'reg-2', name: 'Evening' }];
+      mockFind.mockResolvedValue(items);
+
+      const cursor = Buffer.from('reg-1').toString('base64');
+      const result = await repo.findByHousehold('hh1', 'user-1', { cursor, limit: 20 });
+
+      expect(result.data).toEqual(items);
+      expect(result.pagination.hasMore).toBe(false);
+    });
+
+    it('sets hasMore when more items exist', async () => {
+      const items = Array.from({ length: 3 }, (_, i) => ({ _id: `reg-${i}`, name: `Reg ${i}` }));
+      mockFind.mockResolvedValue(items);
+
+      const result = await repo.findByHousehold('hh1', 'user-1', { limit: 2 });
+
+      expect(result.data).toHaveLength(2);
+      expect(result.pagination.hasMore).toBe(true);
+      expect(result.pagination.cursor).toBeTruthy();
+    });
+
+    it('returns null cursor when no data', async () => {
+      mockFind.mockResolvedValue([]);
+
+      const result = await repo.findByHousehold('hh1', 'user-1', { limit: 20 });
+
+      expect(result.pagination.cursor).toBeNull();
+      expect(result.pagination.hasMore).toBe(false);
+    });
+
+    it('filters by isActive', async () => {
+      mockFind.mockResolvedValue([]);
+
+      await repo.findByHousehold('hh1', 'user-1', { isActive: true, limit: 20 });
+
+      expect(mockFind).toHaveBeenCalled();
+    });
+
+    it('does not add isActive filter when undefined', async () => {
+      mockFind.mockResolvedValue([]);
+
+      await repo.findByHousehold('hh1', 'user-1', { limit: 20 });
+
+      expect(mockFind).toHaveBeenCalled();
+    });
+
+    it('returns cursor only when hasMore is true', async () => {
+      const items = [{ _id: 'reg-1', name: 'Morning' }];
+      mockFind.mockResolvedValue(items);
+
+      const result = await repo.findByHousehold('hh1', 'user-1', { limit: 20 });
+
+      expect(result.pagination.cursor).toBeNull();
+      expect(result.pagination.hasMore).toBe(false);
+    });
+  });
+
+  describe('findById', () => {
+    it('returns regimen by id, householdId, and userId', async () => {
+      const regimen = { _id: 'reg-1', householdId: 'hh1', userId: 'user-1', name: 'Morning' };
+      mockFindOne.mockResolvedValue(regimen);
+
+      const result = await repo.findById('reg-1', 'hh1', 'user-1');
+
+      expect(result).toEqual(regimen);
+    });
+
+    it('returns null when not found', async () => {
+      mockFindOne.mockResolvedValue(null);
+
+      const result = await repo.findById('reg-missing', 'hh1', 'user-1');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('findActiveByUser', () => {
+    it('returns active regimens for user', async () => {
+      const regimens = [
+        { _id: 'reg-1', isActive: true },
+        { _id: 'reg-2', isActive: true },
+      ];
+      mockFind.mockResolvedValue(regimens);
+
+      const result = await repo.findActiveByUser('hh1', 'user-1');
+
+      expect(result).toEqual(regimens);
+    });
+
+    it('returns empty array when no active regimens', async () => {
+      mockFind.mockResolvedValue([]);
+
+      const result = await repo.findActiveByUser('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('create', () => {
+    it('creates and returns regimen', async () => {
+      const data = {
+        name: 'Morning Routine',
+        isActive: true,
+        medications: [
+          {
+            medicineId: 'med-1',
+            medicineName: 'Metformin',
+            medicineStrength: 500,
+            medicineStrengthUnit: 'mg',
+            medicineForm: 'tablet',
+            dosage: 1,
+            dosageUnit: 'tablet',
+            frequency: 'daily',
+          },
+        ],
+      };
+      mockSave.mockImplementation(function (this: { toObject: () => unknown }) {
+        return Promise.resolve(this);
+      });
+
+      const result = await repo.create(data, 'hh1', 'user-1', 'user-1');
+
+      expect(result).toBeTruthy();
+      expect(mockSave).toHaveBeenCalled();
+    });
+  });
+
+  describe('update', () => {
+    it('updates and returns regimen', async () => {
+      const updated = { _id: 'reg-1', name: 'Updated' };
+      mockFindOneAndUpdate.mockResolvedValue(updated);
+
+      const result = await repo.update('reg-1', 'hh1', 'user-1', { name: 'Updated' });
+
+      expect(result).toEqual(updated);
+    });
+
+    it('returns null when regimen not found', async () => {
+      mockFindOneAndUpdate.mockResolvedValue(null);
+
+      const result = await repo.update('reg-missing', 'hh1', 'user-1', { name: 'Updated' });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('softDelete', () => {
+    it('soft deletes and returns regimen', async () => {
+      const deleted = { _id: 'reg-1', isDeleted: true };
+      mockFindOneAndUpdate.mockResolvedValue(deleted);
+
+      const result = await repo.softDelete('reg-1', 'hh1', 'user-1');
+
+      expect(result).toEqual(deleted);
+    });
+
+    it('returns null when regimen not found', async () => {
+      mockFindOneAndUpdate.mockResolvedValue(null);
+
+      const result = await repo.softDelete('reg-missing', 'hh1', 'user-1');
+
+      expect(result).toBeNull();
+    });
+  });
+});

packages/api/tests/modules/regimens/regimens.routes.test.ts

@@ -0,0 +1,494 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import Fastify from 'fastify';
+import { fastifyAwilixPlugin } from '@fastify/awilix';
+import { serializerCompiler, validatorCompiler } from 'fastify-type-provider-zod';
+import { DosageFrequency, DosageUnit, StrengthUnit, MedicineForm } from '@meshitrack/shared';
+
+vi.mock('jose', () => ({
+  createRemoteJWKSet: vi.fn(() => 'mock-jwks'),
+  jwtVerify: vi.fn().mockResolvedValue({
+    payload: {
+      sub: 'kc-1',
+      email: 'test@example.com',
+      preferred_username: 'testuser',
+      realm_access: { roles: ['member'] },
+      householdIds: ['hh1'],
+    },
+    protectedHeader: { alg: 'RS256' },
+    key: {},
+  }),
+}));
+
+const { mockList, mockGetById, mockCreate, mockUpdate, mockDelete, mockCalculateBurnRates } =
+  vi.hoisted(() => ({
+    mockList: vi.fn(),
+    mockGetById: vi.fn(),
+    mockCreate: vi.fn(),
+    mockUpdate: vi.fn(),
+    mockDelete: vi.fn(),
+    mockCalculateBurnRates: vi.fn(),
+  }));
+
+vi.mock('../../../src/modules/regimens/regimens.repository.js', () => ({
+  RegimensRepository: class {
+    findByHousehold = vi.fn();
+    findById = vi.fn();
+    findActiveByUser = vi.fn();
+    create = vi.fn();
+    update = vi.fn();
+    softDelete = vi.fn();
+    delete = vi.fn();
+  },
+}));
+
+vi.mock('../../../src/modules/regimens/regimens.service.js', () => ({
+  RegimensService: class {
+    list = mockList;
+    getById = mockGetById;
+    create = mockCreate;
+    update = mockUpdate;
+    delete = mockDelete;
+    getActiveByUser = vi.fn();
+    calculateBurnRates = mockCalculateBurnRates;
+  },
+}));
+
+vi.mock('../../../src/modules/users/users.repository.js', () => ({
+  UsersRepository: class {
+    findByKeycloakId = vi.fn().mockResolvedValue({ householdIds: ['hh1'] });
+    upsertFromToken = vi.fn().mockResolvedValue({ householdIds: ['hh1'] });
+  },
+}));
+
+import authPlugin from '../../../src/plugins/auth.plugin.js';
+import householdPlugin from '../../../src/plugins/household.plugin.js';
+import usersRoutes from '../../../src/modules/users/users.routes.js';
+import regimensRoutes from '../../../src/modules/regimens/regimens.routes.js';
+
+function makeFakeRegimen(overrides = {}) {
+  return {
+    _id: 'reg-1',
+    householdId: 'hh1',
+    userId: 'kc-1',
+    name: 'Daily Medications',
+    isActive: true,
+    medications: [
+      {
+        medicineId: 'med-1',
+        medicineName: 'Metformin',
+        medicineStrength: 500,
+        medicineStrengthUnit: StrengthUnit.MG,
+        medicineForm: MedicineForm.TABLET,
+        dosage: 1,
+        dosageUnit: DosageUnit.TABLET,
+        frequency: DosageFrequency.DAILY,
+        customFrequencyPerDay: null,
+        timeOfDay: null,
+        instructions: null,
+      },
+    ],
+    createdBy: 'kc-1',
+    createdAt: '2024-06-01T00:00:00.000Z',
+    updatedAt: '2024-06-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+const validPostBody = {
+  name: 'Daily Medications',
+  isActive: true,
+  medications: [
+    {
+      medicineId: 'med-1',
+      dosage: 1,
+      dosageUnit: 'tablet',
+      frequency: 'daily',
+    },
+  ],
+};
+
+describe('regimens.routes', () => {
+  let app: Awaited<ReturnType<typeof buildTestApp>>;
+
+  async function buildTestApp() {
+    const instance = Fastify({ logger: false });
+    instance.setValidatorCompiler(validatorCompiler);
+    instance.setSerializerCompiler(serializerCompiler);
+    await instance.register(fastifyAwilixPlugin, {
+      disposeOnClose: true,
+      disposeOnResponse: true,
+      strictBooleanEnforced: true,
+    });
+    await instance.register(authPlugin);
+    await instance.register(householdPlugin);
+    await instance.register(usersRoutes);
+    await instance.register(regimensRoutes);
+    await instance.ready();
+    return instance;
+  }
+
+  const authHeaders = { authorization: 'Bearer valid-token' };
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    app = await buildTestApp();
+  });
+
+  afterEach(async () => {
+    if (app) await app.close();
+  });
+
+  describe('GET /api/v1/households/:householdId/regimens', () => {
+    it('returns paginated list of regimens', async () => {
+      const regimen = makeFakeRegimen();
+      mockList.mockResolvedValue({
+        data: [regimen],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data).toHaveLength(1);
+      expect(body.data[0].name).toBe('Daily Medications');
+      expect(body.data[0].isActive).toBe(true);
+      expect(body.pagination.hasMore).toBe(false);
+    });
+
+    it('handles ObjectId and Date objects in response', async () => {
+      const regimen = makeFakeRegimen({
+        _id: { toString: () => 'reg-obj' },
+        createdAt: { toISOString: () => '2024-01-01T00:00:00.000Z' },
+        updatedAt: { toISOString: () => '2024-01-02T00:00:00.000Z' },
+      });
+      mockList.mockResolvedValue({
+        data: [regimen],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data[0]._id).toBe('reg-obj');
+      expect(body.data[0].createdAt).toBe('2024-01-01T00:00:00.000Z');
+      expect(body.data[0].updatedAt).toBe('2024-01-02T00:00:00.000Z');
+    });
+
+    it('handles actual Date objects for createdAt/updatedAt', async () => {
+      const regimen = makeFakeRegimen({
+        createdAt: new Date('2024-03-01T00:00:00.000Z'),
+        updatedAt: new Date('2024-03-02T00:00:00.000Z'),
+      });
+      mockList.mockResolvedValue({
+        data: [regimen],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data[0].createdAt).toBe('2024-03-01T00:00:00.000Z');
+      expect(body.data[0].updatedAt).toBe('2024-03-02T00:00:00.000Z');
+    });
+
+    it('includes optional medication fields when present', async () => {
+      const regimen = makeFakeRegimen({
+        medications: [
+          {
+            medicineId: 'med-1',
+            medicineName: 'Metformin',
+            medicineStrength: 500,
+            medicineStrengthUnit: StrengthUnit.MG,
+            medicineForm: MedicineForm.TABLET,
+            dosage: 2,
+            dosageUnit: DosageUnit.TABLET,
+            frequency: DosageFrequency.CUSTOM,
+            customFrequencyPerDay: 4,
+            timeOfDay: 'morning',
+            instructions: 'Take with food',
+          },
+        ],
+      });
+      mockList.mockResolvedValue({
+        data: [regimen],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      const med = body.data[0].medications[0];
+      expect(med.customFrequencyPerDay).toBe(4);
+      expect(med.timeOfDay).toBe('morning');
+      expect(med.instructions).toBe('Take with food');
+    });
+
+    it('omits null optional medication fields from response', async () => {
+      const regimen = makeFakeRegimen();
+      mockList.mockResolvedValue({
+        data: [regimen],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      const med = body.data[0].medications[0];
+      expect(med.customFrequencyPerDay).toBeUndefined();
+      expect(med.timeOfDay).toBeUndefined();
+      expect(med.instructions).toBeUndefined();
+    });
+
+    it('passes query parameters to service', async () => {
+      mockList.mockResolvedValue({
+        data: [],
+        pagination: { cursor: null, hasMore: false },
+      });
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens?isActive=true&limit=5',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(mockList).toHaveBeenCalledWith(
+        'hh1',
+        'kc-1',
+        expect.objectContaining({ isActive: true, limit: 5 }),
+      );
+    });
+  });
+
+  describe('GET /api/v1/households/:householdId/regimens/burn-rate', () => {
+    it('returns burn rate data array', async () => {
+      const burnRateItem = {
+        medicineId: 'med-1',
+        medicineName: 'Metformin',
+        dailyConsumption: 1,
+        totalInCabinet: 30,
+        daysUntilEmpty: 30,
+        earliestExpiry: '2025-01-01T00:00:00.000Z',
+        avgUnitPrice: 2.5,
+        projectedDailyCost: 2.5,
+        projectedMonthlyCost: 75,
+        projectedYearlyCost: 912.5,
+        currency: 'USD',
+      };
+      mockCalculateBurnRates.mockResolvedValue([burnRateItem]);
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens/burn-rate',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data).toHaveLength(1);
+      expect(body.data[0].medicineId).toBe('med-1');
+      expect(body.data[0].medicineName).toBe('Metformin');
+      expect(body.data[0].dailyConsumption).toBe(1);
+      expect(body.data[0].daysUntilEmpty).toBe(30);
+      expect(body.data[0].currency).toBe('USD');
+    });
+
+    it('returns empty array when no active regimens', async () => {
+      mockCalculateBurnRates.mockResolvedValue([]);
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens/burn-rate',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data).toHaveLength(0);
+    });
+
+    it('handles null monetary fields correctly', async () => {
+      const burnRateItem = {
+        medicineId: 'med-1',
+        medicineName: 'Metformin',
+        dailyConsumption: 1,
+        totalInCabinet: 30,
+        daysUntilEmpty: 30,
+        earliestExpiry: null,
+        avgUnitPrice: null,
+        projectedDailyCost: null,
+        projectedMonthlyCost: null,
+        projectedYearlyCost: null,
+        currency: null,
+      };
+      mockCalculateBurnRates.mockResolvedValue([burnRateItem]);
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens/burn-rate',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.data[0].avgUnitPrice).toBeNull();
+      expect(body.data[0].projectedDailyCost).toBeNull();
+      expect(body.data[0].projectedMonthlyCost).toBeNull();
+      expect(body.data[0].projectedYearlyCost).toBeNull();
+      expect(body.data[0].currency).toBeNull();
+    });
+  });
+
+  describe('GET /api/v1/households/:householdId/regimens/:id', () => {
+    it('returns single regimen by id', async () => {
+      mockGetById.mockResolvedValue(makeFakeRegimen());
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens/reg-1',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      const body = res.json();
+      expect(body.name).toBe('Daily Medications');
+      expect(body._id).toBe('reg-1');
+    });
+
+    it('passes id and householdId to service', async () => {
+      mockGetById.mockResolvedValue(makeFakeRegimen());
+
+      await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1/regimens/reg-1',
+        headers: authHeaders,
+      });
+
+      expect(mockGetById).toHaveBeenCalledWith('reg-1', 'hh1', 'kc-1');
+    });
+  });
+
+  describe('POST /api/v1/households/:householdId/regimens', () => {
+    it('creates regimen and returns 201', async () => {
+      mockCreate.mockResolvedValue(makeFakeRegimen());
+
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+        payload: validPostBody,
+      });
+
+      expect(res.statusCode).toBe(201);
+      const body = res.json();
+      expect(body.name).toBe('Daily Medications');
+      expect(body._id).toBe('reg-1');
+    });
+
+    it('returns 400 on invalid body with empty medications array', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+        payload: { name: 'Bad Regimen', isActive: true, medications: [] },
+      });
+
+      expect(res.statusCode).toBe(400);
+    });
+
+    it('returns 400 on invalid body with missing name', async () => {
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households/hh1/regimens',
+        headers: authHeaders,
+        payload: {
+          isActive: true,
+          medications: [
+            {
+              medicineId: 'med-1',
+              dosage: 1,
+              dosageUnit: 'tablet',
+              frequency: 'daily',
+            },
+          ],
+        },
+      });
+
+      expect(res.statusCode).toBe(400);
+    });
+  });
+
+  describe('PATCH /api/v1/households/:householdId/regimens/:id', () => {
+    it('updates regimen and returns 200', async () => {
+      mockUpdate.mockResolvedValue(makeFakeRegimen({ name: 'Updated Regimen' }));
+
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/v1/households/hh1/regimens/reg-1',
+        headers: authHeaders,
+        payload: { name: 'Updated Regimen' },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json().name).toBe('Updated Regimen');
+    });
+
+    it('passes id, householdId, and body to service', async () => {
+      mockUpdate.mockResolvedValue(makeFakeRegimen({ isActive: false }));
+
+      await app.inject({
+        method: 'PATCH',
+        url: '/api/v1/households/hh1/regimens/reg-1',
+        headers: authHeaders,
+        payload: { isActive: false },
+      });
+
+      expect(mockUpdate).toHaveBeenCalledWith(
+        'reg-1',
+        'hh1',
+        'kc-1',
+        expect.objectContaining({ isActive: false }),
+      );
+    });
+  });
+
+  describe('DELETE /api/v1/households/:householdId/regimens/:id', () => {
+    it('deletes regimen and returns 204', async () => {
+      mockDelete.mockResolvedValue(undefined);
+
+      const res = await app.inject({
+        method: 'DELETE',
+        url: '/api/v1/households/hh1/regimens/reg-1',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(204);
+      expect(mockDelete).toHaveBeenCalledWith('reg-1', 'hh1', 'kc-1');
+    });
+  });
+});

packages/api/tests/modules/regimens/regimens.service.test.ts

@@ -0,0 +1,857 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RegimensService } from '../../../src/modules/regimens/regimens.service.js';
+import { DosageFrequency } from '@meshitrack/shared';
+
+describe(RegimensService.name, () => {
+  const mockRegimensRepo = {
+    findByHousehold: vi.fn(),
+    findById: vi.fn(),
+    findActiveByUser: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    softDelete: vi.fn(),
+  };
+
+  const mockMedicinesRepo = {
+    findById: vi.fn(),
+    findByHousehold: vi.fn(),
+    findDuplicate: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    softDelete: vi.fn(),
+  };
+
+  const mockCabinetRepo = {
+    findByHousehold: vi.fn(),
+    findById: vi.fn(),
+    getAggregateSummary: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    adjustQuantity: vi.fn(),
+    findExpiringSoon: vi.fn(),
+    softDelete: vi.fn(),
+    countByMedicineId: vi.fn(),
+    discard: vi.fn(),
+    findActiveByMedicineForFEFO: vi.fn(),
+  };
+
+  const mockCabinetEventsService = {
+    logEvent: vi.fn(),
+    logEvents: vi.fn(),
+    listEvents: vi.fn(),
+    getEventsByItem: vi.fn(),
+    getSpendingSummary: vi.fn(),
+    getAvgUnitPrices: vi.fn(),
+  };
+
+  let service: RegimensService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new RegimensService({
+      regimensRepository: mockRegimensRepo as never,
+      medicinesRepository: mockMedicinesRepo as never,
+      cabinetRepository: mockCabinetRepo as never,
+      cabinetEventsService: mockCabinetEventsService as never,
+    });
+  });
+
+  describe('list', () => {
+    it('delegates to repository', async () => {
+      const result = { data: [], pagination: { cursor: null, hasMore: false } };
+      mockRegimensRepo.findByHousehold.mockResolvedValue(result);
+
+      const response = await service.list('hh1', 'user-1', { limit: 20 });
+
+      expect(response).toEqual(result);
+      expect(mockRegimensRepo.findByHousehold).toHaveBeenCalledWith('hh1', 'user-1', { limit: 20 });
+    });
+  });
+
+  describe('getById', () => {
+    it('returns regimen when found', async () => {
+      const regimen = { _id: 'reg-1', name: 'Morning' };
+      mockRegimensRepo.findById.mockResolvedValue(regimen);
+
+      const result = await service.getById('reg-1', 'hh1', 'user-1');
+
+      expect(result).toEqual(regimen);
+      expect(mockRegimensRepo.findById).toHaveBeenCalledWith('reg-1', 'hh1', 'user-1');
+    });
+
+    it('throws NotFoundError when not found', async () => {
+      mockRegimensRepo.findById.mockResolvedValue(null);
+
+      await expect(service.getById('reg-missing', 'hh1', 'user-1')).rejects.toThrow(
+        'Regimen not found',
+      );
+    });
+  });
+
+  describe('create', () => {
+    const createInput = {
+      name: 'Morning Routine',
+      isActive: true,
+      medications: [
+        {
+          medicineId: 'med-1',
+          dosage: 1,
+          dosageUnit: 'tablet' as const,
+          frequency: DosageFrequency.DAILY,
+        },
+      ],
+    };
+
+    it('creates regimen with denormalized medications', async () => {
+      mockMedicinesRepo.findById.mockResolvedValue({
+        _id: 'med-1',
+        name: 'Metformin',
+        strength: 500,
+        strengthUnit: 'mg',
+        form: 'tablet',
+      });
+      const created = {
+        _id: 'reg-1',
+        ...createInput,
+        medications: [{ medicineId: 'med-1', medicineName: 'Metformin' }],
+      };
+      mockRegimensRepo.create.mockResolvedValue(created);
+
+      const result = await service.create(createInput, 'hh1', 'user-1');
+
+      expect(result).toEqual(created);
+      expect(mockRegimensRepo.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'Morning Routine',
+          isActive: true,
+          medications: expect.arrayContaining([
+            expect.objectContaining({
+              medicineId: 'med-1',
+              medicineName: 'Metformin',
+              medicineStrength: 500,
+              medicineStrengthUnit: 'mg',
+              medicineForm: 'tablet',
+              dosage: 1,
+              dosageUnit: 'tablet',
+              frequency: DosageFrequency.DAILY,
+            }),
+          ]),
+        }),
+        'hh1',
+        'user-1',
+        'user-1',
+      );
+    });
+
+    it('preserves optional medication fields', async () => {
+      mockMedicinesRepo.findById.mockResolvedValue({
+        _id: 'med-1',
+        name: 'Metformin',
+        strength: 500,
+        strengthUnit: 'mg',
+        form: 'tablet',
+      });
+      mockRegimensRepo.create.mockResolvedValue({ _id: 'reg-1' });
+
+      await service.create(
+        {
+          name: 'Morning',
+          isActive: true,
+          medications: [
+            {
+              medicineId: 'med-1',
+              dosage: 2,
+              dosageUnit: 'tablet' as const,
+              frequency: DosageFrequency.CUSTOM,
+              customFrequencyPerDay: 4,
+              timeOfDay: 'morning' as never,
+              instructions: 'Take with food',
+            },
+          ],
+        },
+        'hh1',
+        'user-1',
+      );
+
+      expect(mockRegimensRepo.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          medications: expect.arrayContaining([
+            expect.objectContaining({
+              customFrequencyPerDay: 4,
+              timeOfDay: 'morning',
+              instructions: 'Take with food',
+            }),
+          ]),
+        }),
+        'hh1',
+        'user-1',
+        'user-1',
+      );
+    });
+
+    it('throws NotFoundError when medicine not found', async () => {
+      mockMedicinesRepo.findById.mockResolvedValue(null);
+
+      await expect(service.create(createInput, 'hh1', 'user-1')).rejects.toThrow(
+        'Medicine not found: med-1',
+      );
+    });
+
+    it('denormalizes multiple medications', async () => {
+      mockMedicinesRepo.findById
+        .mockResolvedValueOnce({
+          _id: 'med-1',
+          name: 'Metformin',
+          strength: 500,
+          strengthUnit: 'mg',
+          form: 'tablet',
+        })
+        .mockResolvedValueOnce({
+          _id: 'med-2',
+          name: 'Aspirin',
+          strength: 100,
+          strengthUnit: 'mg',
+          form: 'tablet',
+        });
+      mockRegimensRepo.create.mockResolvedValue({ _id: 'reg-1' });
+
+      await service.create(
+        {
+          name: 'Full Routine',
+          isActive: true,
+          medications: [
+            {
+              medicineId: 'med-1',
+              dosage: 1,
+              dosageUnit: 'tablet' as const,
+              frequency: DosageFrequency.DAILY,
+            },
+            {
+              medicineId: 'med-2',
+              dosage: 1,
+              dosageUnit: 'tablet' as const,
+              frequency: DosageFrequency.TWICE_DAILY,
+            },
+          ],
+        },
+        'hh1',
+        'user-1',
+      );
+
+      expect(mockRegimensRepo.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          medications: expect.arrayContaining([
+            expect.objectContaining({ medicineId: 'med-1', medicineName: 'Metformin' }),
+            expect.objectContaining({ medicineId: 'med-2', medicineName: 'Aspirin' }),
+          ]),
+        }),
+        'hh1',
+        'user-1',
+        'user-1',
+      );
+    });
+  });
+
+  describe('update', () => {
+    it('updates name only', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1', name: 'Morning' });
+      const updated = { _id: 'reg-1', name: 'Evening' };
+      mockRegimensRepo.update.mockResolvedValue(updated);
+
+      const result = await service.update('reg-1', 'hh1', 'user-1', { name: 'Evening' });
+
+      expect(result).toEqual(updated);
+      expect(mockRegimensRepo.update).toHaveBeenCalledWith('reg-1', 'hh1', 'user-1', {
+        name: 'Evening',
+      });
+    });
+
+    it('updates isActive only', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1', isActive: true });
+      mockRegimensRepo.update.mockResolvedValue({ _id: 'reg-1', isActive: false });
+
+      await service.update('reg-1', 'hh1', 'user-1', { isActive: false });
+
+      expect(mockRegimensRepo.update).toHaveBeenCalledWith('reg-1', 'hh1', 'user-1', {
+        isActive: false,
+      });
+    });
+
+    it('updates medications with denormalization', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1', name: 'Morning' });
+      mockMedicinesRepo.findById.mockResolvedValue({
+        _id: 'med-1',
+        name: 'Metformin',
+        strength: 500,
+        strengthUnit: 'mg',
+        form: 'tablet',
+      });
+      mockRegimensRepo.update.mockResolvedValue({ _id: 'reg-1' });
+
+      await service.update('reg-1', 'hh1', 'user-1', {
+        medications: [
+          {
+            medicineId: 'med-1',
+            dosage: 2,
+            dosageUnit: 'tablet' as const,
+            frequency: DosageFrequency.DAILY,
+          },
+        ],
+      });
+
+      expect(mockRegimensRepo.update).toHaveBeenCalledWith(
+        'reg-1',
+        'hh1',
+        'user-1',
+        expect.objectContaining({
+          medications: expect.arrayContaining([
+            expect.objectContaining({ medicineName: 'Metformin' }),
+          ]),
+        }),
+      );
+    });
+
+    it('throws NotFoundError when regimen not found on initial lookup', async () => {
+      mockRegimensRepo.findById.mockResolvedValue(null);
+
+      await expect(
+        service.update('reg-missing', 'hh1', 'user-1', { name: 'Updated' }),
+      ).rejects.toThrow('Regimen not found');
+    });
+
+    it('throws NotFoundError when update returns null', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1', name: 'Morning' });
+      mockRegimensRepo.update.mockResolvedValue(null);
+
+      await expect(service.update('reg-1', 'hh1', 'user-1', { name: 'Updated' })).rejects.toThrow(
+        'Regimen not found',
+      );
+    });
+
+    it('skips undefined fields in updateData', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1' });
+      mockRegimensRepo.update.mockResolvedValue({ _id: 'reg-1' });
+
+      await service.update('reg-1', 'hh1', 'user-1', {});
+
+      expect(mockRegimensRepo.update).toHaveBeenCalledWith('reg-1', 'hh1', 'user-1', {});
+    });
+
+    it('throws NotFoundError when medicine in medications not found', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1' });
+      mockMedicinesRepo.findById.mockResolvedValue(null);
+
+      await expect(
+        service.update('reg-1', 'hh1', 'user-1', {
+          medications: [
+            {
+              medicineId: 'med-missing',
+              dosage: 1,
+              dosageUnit: 'tablet' as const,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        }),
+      ).rejects.toThrow('Medicine not found: med-missing');
+    });
+  });
+
+  describe('delete', () => {
+    it('soft deletes regimen', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1' });
+      mockRegimensRepo.softDelete.mockResolvedValue({ _id: 'reg-1', isDeleted: true });
+
+      const result = await service.delete('reg-1', 'hh1', 'user-1');
+
+      expect(result.isDeleted).toBe(true);
+      expect(mockRegimensRepo.softDelete).toHaveBeenCalledWith('reg-1', 'hh1', 'user-1');
+    });
+
+    it('throws NotFoundError when regimen not found on initial lookup', async () => {
+      mockRegimensRepo.findById.mockResolvedValue(null);
+
+      await expect(service.delete('reg-missing', 'hh1', 'user-1')).rejects.toThrow(
+        'Regimen not found',
+      );
+    });
+
+    it('throws NotFoundError when softDelete returns null', async () => {
+      mockRegimensRepo.findById.mockResolvedValue({ _id: 'reg-1' });
+      mockRegimensRepo.softDelete.mockResolvedValue(null);
+
+      await expect(service.delete('reg-1', 'hh1', 'user-1')).rejects.toThrow('Regimen not found');
+    });
+  });
+
+  describe('getActiveByUser', () => {
+    it('delegates to repository', async () => {
+      const regimens = [{ _id: 'reg-1', isActive: true }];
+      mockRegimensRepo.findActiveByUser.mockResolvedValue(regimens);
+
+      const result = await service.getActiveByUser('hh1', 'user-1');
+
+      expect(result).toEqual(regimens);
+      expect(mockRegimensRepo.findActiveByUser).toHaveBeenCalledWith('hh1', 'user-1');
+    });
+  });
+
+  describe('calculateBurnRates', () => {
+    it('returns empty array when no active regimens', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([]);
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when regimens have no medications', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([{ _id: 'reg-1', medications: [] }]);
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('calculates burn rates for single medicine', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Metformin',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 30, earliestExpiry: new Date('2026-06-01T00:00:00.000Z') },
+      ]);
+
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(
+        new Map([['med-1', { avgUnitPrice: 0.5, currency: 'USD' }]]),
+      );
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].medicineId).toBe('med-1');
+      expect(result[0].medicineName).toBe('Metformin');
+      expect(result[0].dailyConsumption).toBe(1);
+      expect(result[0].totalInCabinet).toBe(30);
+      expect(result[0].daysUntilEmpty).toBe(30);
+      expect(result[0].earliestExpiry).toBe('2026-06-01T00:00:00.000Z');
+      expect(result[0].avgUnitPrice).toBe(0.5);
+      expect(result[0].projectedDailyCost).toBe(0.5);
+      expect(result[0].projectedMonthlyCost).toBe(15);
+      expect(result[0].projectedYearlyCost).toBe(182.5);
+      expect(result[0].currency).toBe('USD');
+    });
+
+    it('sums daily consumption across multiple regimens', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Metformin',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        },
+        {
+          _id: 'reg-2',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Metformin',
+              dosage: 1,
+              frequency: DosageFrequency.TWICE_DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 90, earliestExpiry: null },
+      ]);
+
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // 1*1 + 1*2 = 3 daily
+      expect(result[0].dailyConsumption).toBe(3);
+      expect(result[0].daysUntilEmpty).toBe(30); // 90 / 3 = 30
+      expect(result[0].earliestExpiry).toBeNull();
+      expect(result[0].avgUnitPrice).toBeNull();
+      expect(result[0].projectedDailyCost).toBeNull();
+      expect(result[0].projectedMonthlyCost).toBeNull();
+      expect(result[0].projectedYearlyCost).toBeNull();
+      expect(result[0].currency).toBeNull();
+    });
+
+    it('handles medicine not in cabinet stock', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Metformin',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result[0].totalInCabinet).toBe(0);
+      expect(result[0].daysUntilEmpty).toBe(0); // Math.floor(0/1) = 0
+    });
+
+    it('excludes AS_NEEDED frequency from burn rate results', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Ibuprofen',
+              dosage: 1,
+              frequency: DosageFrequency.AS_NEEDED,
+            },
+          ],
+        },
+      ]);
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('handles CUSTOM frequency with customFrequencyPerDay', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Custom Med',
+              dosage: 2,
+              frequency: DosageFrequency.CUSTOM,
+              customFrequencyPerDay: 3,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 60, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // 2 * 3 = 6 daily
+      expect(result[0].dailyConsumption).toBe(6);
+      expect(result[0].daysUntilEmpty).toBe(10); // 60 / 6 = 10
+    });
+
+    it('excludes CUSTOM frequency without customFrequencyPerDay (zero consumption)', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Custom Med',
+              dosage: 2,
+              frequency: DosageFrequency.CUSTOM,
+              // no customFrequencyPerDay -> 0 daily consumption -> excluded
+            },
+          ],
+        },
+      ]);
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('sorts by daysUntilEmpty ascending (most urgent first, nulls last)', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Med A',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+            {
+              medicineId: 'med-2',
+              medicineName: 'Med B',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+            {
+              medicineId: 'med-3',
+              medicineName: 'Med C',
+              dosage: 1,
+              frequency: DosageFrequency.AS_NEEDED,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 30, earliestExpiry: null },
+        { _id: 'med-2', totalQuantity: 10, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // AS_NEEDED (med-3) excluded; med-2: 10 days, med-1: 30 days
+      expect(result).toHaveLength(2);
+      expect(result[0].medicineId).toBe('med-2');
+      expect(result[0].daysUntilEmpty).toBe(10);
+      expect(result[1].medicineId).toBe('med-1');
+      expect(result[1].daysUntilEmpty).toBe(30);
+    });
+
+    it('returns empty array when all medications are AS_NEEDED', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Med A',
+              dosage: 1,
+              frequency: DosageFrequency.AS_NEEDED,
+            },
+            {
+              medicineId: 'med-2',
+              medicineName: 'Med B',
+              dosage: 1,
+              frequency: DosageFrequency.AS_NEEDED,
+            },
+          ],
+        },
+      ]);
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result).toEqual([]);
+    });
+
+    it('excludes AS_NEEDED from results even when mixed with scheduled frequencies', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Med A',
+              dosage: 1,
+              frequency: DosageFrequency.AS_NEEDED,
+            },
+            {
+              medicineId: 'med-2',
+              medicineName: 'Med B',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+            {
+              medicineId: 'med-3',
+              medicineName: 'Med C',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-2', totalQuantity: 10, earliestExpiry: null },
+        { _id: 'med-3', totalQuantity: 30, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // AS_NEEDED (med-1) excluded; med-2: 10 days, med-3: 30 days
+      expect(result).toHaveLength(2);
+      expect(result[0].medicineId).toBe('med-2');
+      expect(result[0].daysUntilEmpty).toBe(10);
+      expect(result[1].medicineId).toBe('med-3');
+      expect(result[1].daysUntilEmpty).toBe(30);
+    });
+
+    it('handles WEEKLY frequency', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Weekly Med',
+              dosage: 1,
+              frequency: DosageFrequency.WEEKLY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 4, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // 1 * (1/7) ~= 0.1429 daily
+      expect(result[0].dailyConsumption).toBeCloseTo(1 / 7);
+      expect(result[0].daysUntilEmpty).toBe(28); // Math.floor(4 / (1/7)) = 28
+    });
+
+    it('handles EVERY_OTHER_DAY frequency', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'EOD Med',
+              dosage: 1,
+              frequency: DosageFrequency.EVERY_OTHER_DAY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 15, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // 1 * 0.5 = 0.5 daily
+      expect(result[0].dailyConsumption).toBe(0.5);
+      expect(result[0].daysUntilEmpty).toBe(30); // Math.floor(15 / 0.5) = 30
+    });
+
+    it('handles THREE_TIMES_DAILY frequency', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'TID Med',
+              dosage: 1,
+              frequency: DosageFrequency.THREE_TIMES_DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 90, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(new Map());
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      expect(result[0].dailyConsumption).toBe(3);
+      expect(result[0].daysUntilEmpty).toBe(30); // 90 / 3 = 30
+    });
+
+    it('calculates projected costs correctly', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Expensive Med',
+              dosage: 2,
+              frequency: DosageFrequency.DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 60, earliestExpiry: null },
+      ]);
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(
+        new Map([['med-1', { avgUnitPrice: 1.5, currency: 'EUR' }]]),
+      );
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // dailyConsumption = 2, avgUnitPrice = 1.5
+      expect(result[0].projectedDailyCost).toBe(3); // 1.5 * 2
+      expect(result[0].projectedMonthlyCost).toBe(90); // 3 * 30
+      expect(result[0].projectedYearlyCost).toBe(1095); // 3 * 365
+      expect(result[0].currency).toBe('EUR');
+    });
+
+    it('handles multiple medicines with different stock and price data', async () => {
+      mockRegimensRepo.findActiveByUser.mockResolvedValue([
+        {
+          _id: 'reg-1',
+          medications: [
+            {
+              medicineId: 'med-1',
+              medicineName: 'Med A',
+              dosage: 1,
+              frequency: DosageFrequency.DAILY,
+            },
+            {
+              medicineId: 'med-2',
+              medicineName: 'Med B',
+              dosage: 1,
+              frequency: DosageFrequency.TWICE_DAILY,
+            },
+          ],
+        },
+      ]);
+
+      mockCabinetRepo.getAggregateSummary.mockResolvedValue([
+        { _id: 'med-1', totalQuantity: 10, earliestExpiry: new Date('2026-03-01T00:00:00.000Z') },
+        { _id: 'med-2', totalQuantity: 60, earliestExpiry: new Date('2026-12-01T00:00:00.000Z') },
+      ]);
+
+      mockCabinetEventsService.getAvgUnitPrices.mockResolvedValue(
+        new Map([['med-1', { avgUnitPrice: 2.0, currency: 'USD' }]]),
+      );
+
+      const result = await service.calculateBurnRates('hh1', 'user-1');
+
+      // med-1: 10 days until empty, med-2: 30 days
+      expect(result[0].medicineId).toBe('med-1');
+      expect(result[0].daysUntilEmpty).toBe(10);
+      expect(result[0].avgUnitPrice).toBe(2.0);
+      expect(result[1].medicineId).toBe('med-2');
+      expect(result[1].daysUntilEmpty).toBe(30);
+      expect(result[1].avgUnitPrice).toBeNull();
+      expect(result[1].currency).toBeNull();
+    });
+  });
+});