petitspas/backend/src/modules/cards/cards.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { ForbiddenException } from '@nestjs/common';
import { CardsService } from './cards.service';
import { AbsencesGardeService } from '../absences-garde/absences-garde.service';
import { CardType, CardResponseModeType } from 'src/entities/card_types.entity';
import {
  CardInstance,
  CardInstanceStatutType,
  CardOperationType,
} from 'src/entities/card_instances.entity';
import { CardAudienceMember } from 'src/entities/card_audience_members.entity';
import { CardResponse } from 'src/entities/card_responses.entity';
import { AmChildren } from 'src/entities/am_children.entity';
import { ParentsChildren } from 'src/entities/parents_children.entity';
import { RoleType } from 'src/entities/users.entity';
import { StatutAbsenceGardeType, TypeAbsenceGardeType } from 'src/entities/absences_garde.entity';

describe('CardsService (#194)', () => {
  let service: CardsService;

  const typesRepo = { find: jest.fn(), findOne: jest.fn() };
  const cardsRepo = {
    create: jest.fn((x) => x),
    save: jest.fn(async (x) => ({ ...x, id: x.id ?? 'card-1', cree_le: new Date(), modifie_le: new Date() })),
    findOne: jest.fn(),
    delete: jest.fn(),
    createQueryBuilder: jest.fn(),
    manager: { query: jest.fn() },
  };
  const audienceRepo = {
    create: jest.fn((x) => x),
    save: jest.fn(),
    findOne: jest.fn(),
  };
  const responsesRepo = {
    create: jest.fn((x) => x),
    save: jest.fn(),
  };
  const amChildrenRepo = { findOne: jest.fn() };
  const parentsChildrenRepo = { find: jest.fn(), findOne: jest.fn() };
  const absencesService = {
    creer: jest.fn(),
    maj: jest.fn(),
    supprimer: jest.fn(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        CardsService,
        { provide: getRepositoryToken(CardType), useValue: typesRepo },
        { provide: getRepositoryToken(CardInstance), useValue: cardsRepo },
        { provide: getRepositoryToken(CardAudienceMember), useValue: audienceRepo },
        { provide: getRepositoryToken(CardResponse), useValue: responsesRepo },
        { provide: getRepositoryToken(AmChildren), useValue: amChildrenRepo },
        { provide: getRepositoryToken(ParentsChildren), useValue: parentsChildrenRepo },
        { provide: AbsencesGardeService, useValue: absencesService },
      ],
    }).compile();
    service = module.get(CardsService);
    jest.clearAllMocks();
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('AM crée congé → absence + carte ouverte + audience parents', async () => {
    typesRepo.findOne.mockResolvedValue({
      code: 'conge_am',
      system: true,
      titre: 'Congé AM',
      emitter_roles: [RoleType.ASSISTANTE_MATERNELLE],
      recipient_roles: [RoleType.PARENT],
      audience_resolver: 'couple_parents',
      response_mode: CardResponseModeType.ACCEPT_REFUSE,
      retention_days: 14,
      couleur: 'lavender',
    });
    amChildrenRepo.findOne.mockResolvedValue({
      id: 'pl-1',
      amId: 'am-1',
      enfantId: 'e-1',
      date_fin: null,
    });
    absencesService.creer.mockResolvedValue({
      id: 'abs-1',
      type: TypeAbsenceGardeType.CONGE_AM,
      statut: StatutAbsenceGardeType.EN_ATTENTE,
    });
    parentsChildrenRepo.find.mockResolvedValue([
      { parentId: 'p-1', enfantId: 'e-1' },
      { parentId: 'p-2', enfantId: 'e-1' },
    ]);
    cardsRepo.findOne.mockResolvedValue({
      id: 'card-1',
      type_code: 'conge_am',
      id_placement: 'pl-1',
      id_absence: 'abs-1',
      cree_par: 'am-1',
      operation: CardOperationType.CREATE,
      statut: CardInstanceStatutType.OUVERTE,
      payload: { date_debut: '2026-11-01', date_fin: '2026-11-07' },
      purge_at: new Date(),
      cree_le: new Date(),
      modifie_le: new Date(),
      type: {
        titre: 'Congé AM',
        couleur: 'lavender',
        response_mode: CardResponseModeType.ACCEPT_REFUSE,
        retention_days: 14,
      },
      responses: [],
      audience: [],
    });

    const res = await service.creer('am-1', RoleType.ASSISTANTE_MATERNELLE, {
      type_code: 'conge_am',
      id_placement: 'pl-1',
      date_debut: '2026-11-01',
      date_fin: '2026-11-07',
    });

    expect(absencesService.creer).toHaveBeenCalled();
    expect(audienceRepo.save).toHaveBeenCalled();
    expect(res.type_code).toBe('conge_am');
    expect(res.statut).toBe(CardInstanceStatutType.OUVERTE);
  });

  it('parent ne peut pas émettre conge_am', async () => {
    typesRepo.findOne.mockResolvedValue({
      code: 'conge_am',
      system: true,
      emitter_roles: [RoleType.ASSISTANTE_MATERNELLE],
    });
    await expect(
      service.creer('p-1', RoleType.PARENT, {
        type_code: 'conge_am',
        id_placement: 'pl-1',
        date_debut: '2026-11-01',
        date_fin: '2026-11-07',
      }),
    ).rejects.toBeInstanceOf(ForbiddenException);
  });
});