Tests refactor

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

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HouseholdRole } from '@meshitrack/shared';
+
+const { _mockLean, mockExec, mockFindById, mockFindOne, mockFindByIdAndUpdate, mockSave } =
+  vi.hoisted(() => {
+    const mockExec = vi.fn();
+    const mockLean = vi.fn(() => ({ exec: mockExec }));
+    return {
+      mockExec,
+      mockLean,
+      mockFindById: vi.fn(() => ({ lean: mockLean })),
+      mockFindOne: vi.fn(() => ({ lean: mockLean })),
+      mockFindByIdAndUpdate: vi.fn(() => ({ exec: mockExec })),
+      mockSave: vi.fn(),
+    };
+  });
+
+vi.mock('../../../src/schemas/household.schema.js', () => {
+  class MockHouseholdModel {
+    _data: Record<string, unknown>;
+    constructor(data: Record<string, unknown>) {
+      this._data = data;
+      Object.assign(this, data);
+    }
+    save() {
+      mockSave();
+      return Promise.resolve(this);
+    }
+    toObject() {
+      return { _id: 'hh-new', ...this._data };
+    }
+    static findById = mockFindById;
+    static findOne = mockFindOne;
+    static findByIdAndUpdate = mockFindByIdAndUpdate;
+  }
+  return { HouseholdModel: MockHouseholdModel };
+});
+
+import { HouseholdsRepository } from '../../../src/modules/households/households.repository.js';
+
+describe('HouseholdsRepository', () => {
+  let repo: HouseholdsRepository;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    repo = new HouseholdsRepository();
+  });
+
+  describe('findById', () => {
+    it('calls findById with lean', async () => {
+      const household = { _id: 'hh1', name: 'Test' };
+      mockExec.mockResolvedValue(household);
+
+      const result = await repo.findById('hh1');
+
+      expect(mockFindById).toHaveBeenCalledWith('hh1');
+      expect(result).toEqual(household);
+    });
+  });
+
+  describe('findByInviteCode', () => {
+    it('calls findOne with inviteCode', async () => {
+      const household = { _id: 'hh1', inviteCode: 'ABCD' };
+      mockExec.mockResolvedValue(household);
+
+      const result = await repo.findByInviteCode('ABCD');
+
+      expect(mockFindOne).toHaveBeenCalledWith({ inviteCode: 'ABCD' });
+      expect(result).toEqual(household);
+    });
+  });
+
+  describe('create', () => {
+    it('creates a household with owner as first member', async () => {
+      mockSave.mockResolvedValue({});
+
+      const result = await repo.create({ name: 'Test' }, 'owner-1', 'INVITE1');
+
+      expect(mockSave).toHaveBeenCalled();
+      expect(result).toMatchObject({ name: 'Test', ownerUserId: 'owner-1', inviteCode: 'INVITE1' });
+    });
+  });
+
+  describe('update', () => {
+    it('calls findByIdAndUpdate with $set', async () => {
+      mockExec.mockResolvedValue({ _id: 'hh1', name: 'Updated' });
+
+      const result = await repo.update('hh1', { name: 'Updated' });
+
+      expect(mockFindByIdAndUpdate).toHaveBeenCalledWith(
+        'hh1',
+        { $set: { name: 'Updated' } },
+        { new: true, lean: true },
+      );
+      expect(result).toEqual({ _id: 'hh1', name: 'Updated' });
+    });
+  });
+
+  describe('addMember', () => {
+    it('pushes a new member to the array', async () => {
+      mockExec.mockResolvedValue({ _id: 'hh1', members: [] });
+
+      await repo.addMember('hh1', 'user-2', HouseholdRole.MEMBER);
+
+      expect(mockFindByIdAndUpdate).toHaveBeenCalledWith(
+        'hh1',
+        {
+          $push: {
+            members: expect.objectContaining({
+              userId: 'user-2',
+              role: HouseholdRole.MEMBER,
+            }),
+          },
+        },
+        { new: true, lean: true },
+      );
+    });
+  });
+
+  describe('updateInviteCode', () => {
+    it('sets the new invite code', async () => {
+      mockExec.mockResolvedValue({ _id: 'hh1', inviteCode: 'NEWCODE' });
+
+      const result = await repo.updateInviteCode('hh1', 'NEWCODE');
+
+      expect(mockFindByIdAndUpdate).toHaveBeenCalledWith(
+        'hh1',
+        { $set: { inviteCode: 'NEWCODE' } },
+        { new: true, lean: true },
+      );
+      expect(result).toEqual({ _id: 'hh1', inviteCode: 'NEWCODE' });
+    });
+  });
+});

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

@@ -0,0 +1,265 @@
+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 { HouseholdRole } from '@meshitrack/shared';
+
+// Mock jose for auth plugin
+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: {},
+  }),
+}));
+
+// Hoist mock fns
+const {
+  mockCreate,
+  mockFindById,
+  mockUpdate,
+  mockUpdateInviteCode,
+  mockFindByInviteCode,
+  mockAddMember,
+  mockFindByKeycloakId,
+  mockUserUpdate,
+} = vi.hoisted(() => ({
+  mockCreate: vi.fn(),
+  mockFindById: vi.fn(),
+  mockUpdate: vi.fn(),
+  mockUpdateInviteCode: vi.fn(),
+  mockFindByInviteCode: vi.fn(),
+  mockAddMember: vi.fn(),
+  mockFindByKeycloakId: vi.fn(),
+  mockUserUpdate: vi.fn(),
+}));
+
+vi.mock('../../../src/modules/households/households.repository.js', () => ({
+  HouseholdsRepository: class {
+    create = mockCreate;
+    findById = mockFindById;
+    update = mockUpdate;
+    updateInviteCode = mockUpdateInviteCode;
+    findByInviteCode = mockFindByInviteCode;
+    addMember = mockAddMember;
+  },
+}));
+
+vi.mock('../../../src/modules/users/users.repository.js', () => ({
+  UsersRepository: class {
+    findByKeycloakId = mockFindByKeycloakId;
+    update = mockUserUpdate;
+    upsertFromToken = vi.fn().mockResolvedValue({ householdIds: ['hh1'] });
+  },
+}));
+
+vi.mock('uuid', () => ({
+  v4: vi.fn(() => '12345678-1234-1234-1234-123456789abc'),
+}));
+
+vi.mock('mongoose', () => ({
+  default: {
+    startSession: vi.fn().mockResolvedValue({
+      startTransaction: vi.fn(),
+      commitTransaction: vi.fn().mockResolvedValue(undefined),
+      abortTransaction: vi.fn().mockResolvedValue(undefined),
+      endSession: vi.fn(),
+    }),
+  },
+}));
+
+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 householdsRoutes from '../../../src/modules/households/households.routes.js';
+
+function makeFakeHousehold(overrides = {}) {
+  return {
+    _id: 'hh1',
+    name: 'Test Household',
+    ownerUserId: 'kc-1',
+    members: [{ userId: 'kc-1', role: HouseholdRole.OWNER, joinedAt: new Date().toISOString() }],
+    inviteCode: '12345678',
+    settings: { timezone: 'UTC', currency: 'USD', language: 'en' },
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('households.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(householdsRoutes);
+    await instance.ready();
+    return instance;
+  }
+
+  const authHeaders = { authorization: 'Bearer valid-token' };
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Default: auth plugin finds user with hh1 membership (routes with householdId guard pass)
+    mockFindByKeycloakId.mockResolvedValue({ householdIds: ['hh1'], defaultHouseholdId: null });
+    app = await buildTestApp();
+  });
+
+  afterEach(async () => {
+    if (app) await app.close();
+  });
+
+  describe('POST /api/v1/households', () => {
+    it('creates a household', async () => {
+      const household = makeFakeHousehold();
+      mockCreate.mockResolvedValue(household);
+      mockFindByKeycloakId.mockResolvedValue({ householdIds: [], defaultHouseholdId: null });
+      mockUserUpdate.mockResolvedValue({});
+
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households',
+        headers: authHeaders,
+        payload: { name: 'Test Household' },
+      });
+
+      expect(res.statusCode).toBe(201);
+      expect(res.json().name).toBe('Test Household');
+    });
+  });
+
+  describe('POST /api/v1/households (ObjectId/Date conversion)', () => {
+    it('handles ObjectId and Date objects in response', async () => {
+      const household = makeFakeHousehold({
+        _id: { toString: () => 'hh-obj' },
+        createdAt: { toISOString: () => '2024-01-01T00:00:00.000Z' },
+        updatedAt: { toISOString: () => '2024-01-02T00:00:00.000Z' },
+        members: [
+          {
+            userId: 'kc-1',
+            role: HouseholdRole.OWNER,
+            joinedAt: { toISOString: () => '2024-01-01T00:00:00.000Z' },
+          },
+        ],
+        settings: null,
+      });
+      mockCreate.mockResolvedValue(household);
+      mockFindByKeycloakId.mockResolvedValue({ householdIds: [], defaultHouseholdId: null });
+      mockUserUpdate.mockResolvedValue({});
+
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households',
+        headers: authHeaders,
+        payload: { name: 'Test' },
+      });
+
+      expect(res.statusCode).toBe(201);
+      const body = res.json();
+      expect(body._id).toBe('hh-obj');
+      expect(body.createdAt).toBe('2024-01-01T00:00:00.000Z');
+      expect(body.members[0].joinedAt).toBe('2024-01-01T00:00:00.000Z');
+      expect(body.settings.timezone).toBe('UTC');
+      expect(body.settings.currency).toBe('USD');
+      expect(body.settings.language).toBe('en');
+    });
+  });
+
+  describe('GET /api/v1/households/:id', () => {
+    it('returns a household', async () => {
+      const household = makeFakeHousehold();
+      mockFindById.mockResolvedValue(household);
+
+      const res = await app.inject({
+        method: 'GET',
+        url: '/api/v1/households/hh1',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json().name).toBe('Test Household');
+    });
+  });
+
+  describe('PATCH /api/v1/households/:id', () => {
+    it('updates a household', async () => {
+      const household = makeFakeHousehold();
+      mockFindById.mockResolvedValue(household);
+      mockUpdate.mockResolvedValue({ ...household, name: 'Updated' });
+
+      const res = await app.inject({
+        method: 'PATCH',
+        url: '/api/v1/households/hh1',
+        headers: authHeaders,
+        payload: { name: 'Updated' },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json().name).toBe('Updated');
+    });
+  });
+
+  describe('POST /api/v1/households/:id/invite', () => {
+    it('generates a new invite code', async () => {
+      const household = makeFakeHousehold();
+      mockFindById.mockResolvedValue(household);
+      mockUpdateInviteCode.mockResolvedValue({ ...household, inviteCode: '12345678' });
+
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households/hh1/invite',
+        headers: authHeaders,
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(res.json().inviteCode).toBeDefined();
+    });
+  });
+
+  describe('POST /api/v1/households/join', () => {
+    it('joins a household via invite code', async () => {
+      const household = makeFakeHousehold({
+        members: [
+          { userId: 'kc-other', role: HouseholdRole.OWNER, joinedAt: new Date().toISOString() },
+        ],
+      });
+      mockFindByInviteCode.mockResolvedValue(household);
+      mockAddMember.mockResolvedValue({
+        ...household,
+        members: [
+          ...household.members,
+          { userId: 'kc-1', role: HouseholdRole.MEMBER, joinedAt: new Date().toISOString() },
+        ],
+      });
+      mockFindByKeycloakId.mockResolvedValue({ householdIds: [], defaultHouseholdId: null });
+      mockUserUpdate.mockResolvedValue({});
+
+      const res = await app.inject({
+        method: 'POST',
+        url: '/api/v1/households/join',
+        headers: authHeaders,
+        payload: { inviteCode: '12345678' },
+      });
+
+      expect(res.statusCode).toBe(200);
+    });
+  });
+});

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

@@ -0,0 +1,307 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { HouseholdsService } from '../../../src/modules/households/households.service.js';
+import { NotFoundError, ForbiddenError, ConflictError } from '../../../src/common/errors.js';
+import { HouseholdRole } from '@meshitrack/shared';
+
+// Mock uuid to return deterministic values
+vi.mock('uuid', () => ({
+  v4: vi.fn(() => '12345678-1234-1234-1234-123456789abc'),
+}));
+
+const { mockSession } = vi.hoisted(() => ({
+  mockSession: {
+    startTransaction: vi.fn(),
+    commitTransaction: vi.fn().mockResolvedValue(undefined),
+    abortTransaction: vi.fn().mockResolvedValue(undefined),
+    endSession: vi.fn(),
+  },
+}));
+
+vi.mock('mongoose', () => ({
+  default: { startSession: vi.fn().mockResolvedValue(mockSession) },
+}));
+
+describe('HouseholdsService', () => {
+  const mockHouseholdsRepo = {
+    findById: vi.fn(),
+    findByInviteCode: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    addMember: vi.fn(),
+    updateInviteCode: vi.fn(),
+  };
+
+  const mockUsersRepo = {
+    findByKeycloakId: vi.fn(),
+    findById: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    upsertFromToken: vi.fn(),
+  };
+
+  let service: HouseholdsService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new HouseholdsService({
+      householdsRepository: mockHouseholdsRepo as never,
+      usersRepository: mockUsersRepo as never,
+    });
+  });
+
+  describe('create', () => {
+    it('creates a household and updates owner user', async () => {
+      const household = { _id: 'hh1', name: 'Test', ownerUserId: 'kc-1', inviteCode: '12345678' };
+      mockHouseholdsRepo.create.mockResolvedValue(household);
+      mockUsersRepo.findByKeycloakId.mockResolvedValue({
+        householdIds: [],
+        defaultHouseholdId: null,
+      });
+      mockUsersRepo.update.mockResolvedValue({});
+
+      const result = await service.create({ name: 'Test' }, 'kc-1');
+
+      expect(result).toEqual(household);
+      expect(mockHouseholdsRepo.create).toHaveBeenCalledWith(
+        { name: 'Test' },
+        'kc-1',
+        '12345678',
+        mockSession,
+      );
+      expect(mockUsersRepo.update).toHaveBeenCalledWith(
+        'kc-1',
+        { householdIds: ['hh1'], defaultHouseholdId: 'hh1' },
+        mockSession,
+      );
+    });
+
+    it('preserves existing defaultHouseholdId when user already has one', async () => {
+      const household = { _id: 'hh2', name: 'Second', ownerUserId: 'kc-1' };
+      mockHouseholdsRepo.create.mockResolvedValue(household);
+      mockUsersRepo.findByKeycloakId.mockResolvedValue({
+        householdIds: ['hh1'],
+        defaultHouseholdId: 'hh1',
+      });
+      mockUsersRepo.update.mockResolvedValue({});
+
+      await service.create({ name: 'Second' }, 'kc-1');
+
+      expect(mockUsersRepo.update).toHaveBeenCalledWith(
+        'kc-1',
+        { householdIds: ['hh1', 'hh2'], defaultHouseholdId: 'hh1' },
+        mockSession,
+      );
+    });
+
+    it('aborts transaction on error', async () => {
+      mockHouseholdsRepo.create.mockRejectedValue(new Error('DB error'));
+
+      await expect(service.create({ name: 'Test' }, 'kc-1')).rejects.toThrow('DB error');
+
+      expect(mockSession.abortTransaction).toHaveBeenCalled();
+      expect(mockSession.endSession).toHaveBeenCalled();
+    });
+
+    it('handles case when owner user not found in db', async () => {
+      const household = { _id: 'hh1', name: 'Test', ownerUserId: 'kc-1' };
+      mockHouseholdsRepo.create.mockResolvedValue(household);
+      mockUsersRepo.findByKeycloakId.mockResolvedValue(null);
+
+      const result = await service.create({ name: 'Test' }, 'kc-1');
+
+      expect(result).toEqual(household);
+      expect(mockUsersRepo.update).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getById', () => {
+    it('returns household when found', async () => {
+      const household = { _id: 'hh1', name: 'Test' };
+      mockHouseholdsRepo.findById.mockResolvedValue(household);
+
+      const result = await service.getById('hh1');
+      expect(result).toEqual(household);
+    });
+
+    it('throws NotFoundError when not found', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue(null);
+
+      await expect(service.getById('missing')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('update', () => {
+    it('allows owner to update', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+      mockHouseholdsRepo.update.mockResolvedValue({ _id: 'hh1', name: 'Updated' });
+
+      const result = await service.update('hh1', { name: 'Updated' }, 'kc-1');
+      expect(result).toEqual({ _id: 'hh1', name: 'Updated' });
+    });
+
+    it('allows admin to update', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-2', role: HouseholdRole.ADMIN }],
+      });
+      mockHouseholdsRepo.update.mockResolvedValue({ _id: 'hh1', name: 'Updated' });
+
+      await service.update('hh1', { name: 'Updated' }, 'kc-2');
+      expect(mockHouseholdsRepo.update).toHaveBeenCalled();
+    });
+
+    it('throws ForbiddenError for regular member', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-3', role: HouseholdRole.MEMBER }],
+      });
+
+      await expect(service.update('hh1', { name: 'X' }, 'kc-3')).rejects.toThrow(ForbiddenError);
+    });
+
+    it('throws NotFoundError when repo update returns null', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+      mockHouseholdsRepo.update.mockResolvedValue(null);
+
+      await expect(service.update('hh1', { name: 'X' }, 'kc-1')).rejects.toThrow(NotFoundError);
+    });
+
+    it('throws ForbiddenError for non-member', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+
+      await expect(service.update('hh1', { name: 'X' }, 'kc-other')).rejects.toThrow(
+        ForbiddenError,
+      );
+    });
+  });
+
+  describe('generateInviteCode', () => {
+    it('generates new invite code for owner', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+      mockHouseholdsRepo.updateInviteCode.mockResolvedValue({ inviteCode: '12345678' });
+
+      const result = await service.generateInviteCode('hh1', 'kc-1');
+      expect(mockHouseholdsRepo.updateInviteCode).toHaveBeenCalledWith('hh1', '12345678');
+      expect(result).toEqual({ inviteCode: '12345678' });
+    });
+
+    it('throws ForbiddenError for regular member', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-3', role: HouseholdRole.MEMBER }],
+      });
+
+      await expect(service.generateInviteCode('hh1', 'kc-3')).rejects.toThrow(ForbiddenError);
+    });
+
+    it('throws NotFoundError when updateInviteCode returns null', async () => {
+      mockHouseholdsRepo.findById.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+      mockHouseholdsRepo.updateInviteCode.mockResolvedValue(null);
+
+      await expect(service.generateInviteCode('hh1', 'kc-1')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('join', () => {
+    it('joins a household via invite code', async () => {
+      const household = {
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      };
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue(household);
+      mockHouseholdsRepo.addMember.mockResolvedValue({
+        ...household,
+        members: [...household.members, { userId: 'kc-2' }],
+      });
+      mockUsersRepo.findByKeycloakId.mockResolvedValue({
+        householdIds: [],
+        defaultHouseholdId: null,
+      });
+      mockUsersRepo.update.mockResolvedValue({});
+
+      const result = await service.join('ABCD1234', 'kc-2');
+
+      expect(mockHouseholdsRepo.addMember).toHaveBeenCalledWith(
+        'hh1',
+        'kc-2',
+        HouseholdRole.MEMBER,
+        mockSession,
+      );
+      expect(mockUsersRepo.update).toHaveBeenCalledWith(
+        'kc-2',
+        { householdIds: ['hh1'], defaultHouseholdId: 'hh1' },
+        mockSession,
+      );
+      expect(result).toBeDefined();
+    });
+
+    it('throws NotFoundError for invalid invite code', async () => {
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue(null);
+
+      await expect(service.join('INVALID', 'kc-2')).rejects.toThrow(NotFoundError);
+    });
+
+    it('throws ConflictError when already a member', async () => {
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue({
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      });
+
+      await expect(service.join('CODE', 'kc-1')).rejects.toThrow(ConflictError);
+    });
+
+    it('throws NotFoundError when addMember returns null', async () => {
+      const household = {
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      };
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue(household);
+      mockHouseholdsRepo.addMember.mockResolvedValue(null);
+
+      await expect(service.join('CODE', 'kc-2')).rejects.toThrow(NotFoundError);
+    });
+
+    it('aborts transaction on error during join', async () => {
+      const household = {
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      };
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue(household);
+      mockHouseholdsRepo.addMember.mockRejectedValue(new Error('DB error'));
+
+      await expect(service.join('CODE', 'kc-2')).rejects.toThrow('DB error');
+
+      expect(mockSession.abortTransaction).toHaveBeenCalled();
+      expect(mockSession.endSession).toHaveBeenCalled();
+    });
+
+    it('handles case when joining user not found in db', async () => {
+      const household = {
+        _id: 'hh1',
+        members: [{ userId: 'kc-1', role: HouseholdRole.OWNER }],
+      };
+      mockHouseholdsRepo.findByInviteCode.mockResolvedValue(household);
+      mockHouseholdsRepo.addMember.mockResolvedValue({});
+      mockUsersRepo.findByKeycloakId.mockResolvedValue(null);
+
+      await service.join('CODE', 'kc-new');
+
+      expect(mockUsersRepo.update).not.toHaveBeenCalled();
+    });
+  });
+});