Tests

modules/members/
├── members.service.ts
├── members.service.test.ts          ← unit
├── members.repository.ts
├── members.repository.test.ts       ← intégration (DB)
├── members.routes.ts
└── members.routes.test.ts           ← intégration (Elysia handle)

members.service.test.ts                  → 700 lignes, on splitte
↓
members.service.create.test.ts           ← scénarios de création
members.service.search.test.ts           ← scénarios de recherche
members.service.update.test.ts           ← scénarios d'update

test('should return null when member does not exist', async () => { /* */ });
test('should throw MemberInactiveError when member is inactive', async () => { /* */ });
test('should advance status from "qualifying" to "searching" when description is set', async () => { /* */ });

test('should calculate commission with new client rate when isFirstClient is true', () => {
  // Arrange
  const request = makeRequest({ amount: 1000, isFirstClient: true });
  const rule = makeCommissionRule({ defaultRate: 0.10, newClientRate: 0.15 });

  // Act
  const commission = calculateCommission(request, rule);

  // Assert
  expect(commission.amount).toBe(150);
  expect(commission.rateReason).toBe('new_client');
});

// ✅
test('should emit "request.member_added_to_results" when adding a member', async () => {
  const emitSpy = mock(emit);
  await requestsService.addMember(reqId, memberId, { actorId: userId });
  expect(emitSpy).toHaveBeenCalledWith('request.member_added_to_results', expect.objectContaining({ memberId }), expect.anything());
});

// ❌ Test inutile
test('should call db.insert', async () => {
  const insertSpy = mock(db.insert);
  await requestsService.create({ /* ... */ });
  expect(insertSpy).toHaveBeenCalled();
});

test('findById should return the member with its rooms', async () => {
  const member = await seed.member({ name: 'Loft 42' });
  await seed.room({ memberId: member.id, name: 'Salle A' });

  const found = await membersRepository.findById(member.id);

  expect(found?.name).toBe('Loft 42');
  expect(found?.rooms).toHaveLength(1);
});

import { app } from '@/app';

test('POST /requests should return 201 with the created request', async () => {
  const res = await app.handle(
    new Request('http://localhost/api/v1/requests', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', cookie: validSessionCookie },
      body: JSON.stringify({ description: 'test', participantsCount: 50 }),
    }),
  );

  expect(res.status).toBe(201);
  const body = await res.json();
  expect(body).toMatchObject({ description: 'test', participantsCount: 50 });
});

test('should call onClick when the user clicks the button', () => {
  const handleClick = mock();
  render(<MemberCard member={mockMember} onClick={handleClick} />);

  fireEvent.click(screen.getByRole('button', { name: /voir le membre/i }));

  expect(handleClick).toHaveBeenCalledTimes(1);
});

test('useDebounce should return the latest value after the delay', async () => {
  const { result, rerender } = renderHook(({ v }) => useDebounce(v, 100), { initialProps: { v: 'a' } });
  rerender({ v: 'b' });
  expect(result.current).toBe('a');
  await new Promise((r) => setTimeout(r, 110));
  expect(result.current).toBe('b');
});

export const anthropicMock = {
  messages: {
    create: mock(async () => ({
      content: [{ type: 'text', text: 'mocked response' }],
      stop_reason: 'end_turn',
    })),
    stream: mock(async function* () {
      yield { type: 'message_delta' };
    }),
  },
};

import { anthropicMock } from '@/lib/anthropic-mock';

beforeEach(() => {
  globalAnthropic = anthropicMock as unknown as Anthropic;
});

export const emailStub = {
  sent: [] as Array<{ to: string; subject: string; body: string }>,
  send(args: { to: string; subject: string; body: string }) {
    this.sent.push(args);
  },
  reset() {
    this.sent = [];
  },
};

test('should send a catalog email to the organizer', async () => {
  emailStub.reset();
  await catalogService.sendCatalog(catalogId);
  expect(emailStub.sent).toHaveLength(1);
  expect(emailStub.sent[0].to).toBe(organizer.email);
});

import type { Member } from '@reciprok/db/schema';
import { faker } from '@faker-js/faker/locale/fr';

export function makeMember(overrides: Partial<Member> = {}): Member {
  return {
    id: faker.string.uuid(),
    code: `#${faker.number.int({ min: 100, max: 999 })}`,
    name: faker.company.name(),
    description: faker.lorem.paragraph(),
    postalCode: faker.location.zipCode('#####'),
    status: 'active',
    createdAt: new Date(),
    updatedAt: new Date(),
    ...overrides,
  };
}

const member = makeMember({ status: 'inactive' });

import { db } from '@reciprok/db';
import { member } from '@reciprok/db/schema';
import { makeMember } from './factories/member.factory';

export const seed = {
  async member(overrides: Partial<typeof member.$inferInsert> = {}) {
    const data = makeMember(overrides);
    const [created] = await db.insert(member).values(data).returning();
    return created;
  },

  async request(overrides: Partial<typeof request.$inferInsert> = {}) {
    /* ... */
  },
};

import { beforeEach } from 'bun:test';
import { db } from '@reciprok/db';
import { sql } from 'drizzle-orm';

beforeEach(async () => {
  await db.execute(sql`TRUNCATE TABLE member, request, organizer, ... RESTART IDENTITY CASCADE`);
});

bun test --coverage

// SKIPPED: dépend de l'API Meta réelle, à reactiver après mock, voir #142
test.skip('should handle WhatsApp inbound media', async () => { /* */ });

test('something', () => {
  doStuff();
  expect(true).toBe(true);
});

test('createMember', async () => {
  const dbMock = mock();
  const validatorMock = mock(() => true);
  const eventEmitterMock = mock();
  const result = await createMember({ db: dbMock, validator: validatorMock, ...});
  expect(dbMock).toHaveBeenCalled();
});

expect(component).toMatchSnapshot();

// ❌
test('test A creates a member', async () => { /* crée member 42 */ });
test('test B reads member 42', async () => { /* dépend de A */ });

// ✅ Chaque test crée ses propres données
test('test A creates a member', async () => { const m = await seed.member(); /* */ });
test('test B reads a member', async () => { const m = await seed.member(); /* */ });

// ❌
test('should call db.query.member.findFirst', async () => {
  const spy = mock(db.query.member, 'findFirst');
  await membersService.byId('123');
  expect(spy).toHaveBeenCalled();
});

// ✅
test('should return the member when it exists', async () => {
  const m = await seed.member({ id: '123', name: 'Test' });
  const found = await membersService.byId('123');
  expect(found?.name).toBe('Test');
});