siop2/apps/api/test/recherche.e2e-spec.ts

/**
 * E2E R3 (recette) — recherche globale : chaque famille de résultats est
 * filtrée par la matrice, les OT respectent « voir autre » ; au passage,
 * rattachements Tiers (siteNames) et période analytics paramétrable.
 */
process.env.DEMO_MODE = 'true';

import { INestApplication } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { PrismaClient } from '@prisma/client';
import request from 'supertest';
import { seed } from '../prisma/seed';
import { AppModule } from '../src/app.module';

describe('Recherche globale & corrections de recette R3 (e2e)', () => {
  let app: INestApplication;
  let yasmine: string; // Administrateur
  let salma: string; // Dispatcher (voir autre)
  let youssef: string; // Technicien limité : SES OT, ASSETS view, pas de LOCATIONS
  let karim: string; // Demandeur : aucune des trois familles
  let otId: string;
  const prisma = new PrismaClient();
  const http = () => request(app.getHttpServer());
  const auth = (t: string) => ({ Authorization: `Bearer ${t}` });
  const suffix = `rech-${Date.now().toString(36)}`;

  beforeAll(async () => {
    await seed(prisma);
    const moduleRef = await Test.createTestingModule({
      imports: [AppModule.forRoot()],
    }).compile();
    app = moduleRef.createNestApplication();
    await app.init();
    const { body } = await http().get('/auth/demo-accounts');
    const login = async (roleName: string) => {
      const compte = body.accounts.find((a: { roleName: string }) => a.roleName === roleName);
      return (await http().post('/auth/demo-login').send({ userId: compte.id })).body
        .accessToken as string;
    };
    yasmine = await login('Administrateur');
    salma = await login('Dispatcher');
    youssef = await login('Technicien limité');
    karim = await login('Demandeur');

    // Un OT au titre unique, assigné à Ahmed (PAS à Youssef).
    const { body: assets } = await http().get('/assets').set(auth(salma));
    const a1 = assets.assets.find((a: { reference: string }) => a.reference === 'A1');
    const ahmed = body.accounts.find((a: { roleName: string }) => a.roleName === 'Technicien');
    const cree = await http()
      .post('/work-orders')
      .set(auth(salma))
      .send({
        title: `Recherche E2E ${suffix}`,
        type: 'CORRECTIVE',
        priority: 'LOW',
        assetId: a1.id,
        assigneeIds: [ahmed.id],
      })
      .expect(201);
    otId = cree.body.id;
  });

  afterAll(async () => {
    await prisma.workOrder.deleteMany({ where: { title: { contains: suffix } } });
    await app?.close();
    await prisma.$disconnect();
  });

  it('dispatcher (voir autre) : OT par titre, appareil par référence, site insensible à la casse', async () => {
    const parTitre = await http().get(`/search?q=${suffix}`).set(auth(salma)).expect(200);
    expect(parTitre.body.workOrders.map((w: { id: string }) => w.id)).toContain(otId);

    const parRef = await http().get('/search?q=A1').set(auth(salma)).expect(200);
    expect(parRef.body.assets.some((a: { reference: string }) => a.reference === 'A1')).toBe(true);
    expect(parRef.body.assets[0].siteName).toBeTruthy();

    const parSite = await http().get('/search?q=atlas').set(auth(salma)).expect(200);
    expect(parSite.body.sites.some((s: { name: string }) => s.name === 'Tour Atlas')).toBe(true);
  });

  it('technicien limité : ne trouve pas l’OT d’un autre, ni les sites ; le parc oui', async () => {
    const res = await http().get(`/search?q=${suffix}`).set(auth(youssef)).expect(200);
    expect(res.body.workOrders).toHaveLength(0); // pas « voir autre »

    const parc = await http().get('/search?q=A1').set(auth(youssef)).expect(200);
    expect(parc.body.assets.length).toBeGreaterThan(0); // ASSETS view
    const sites = await http().get('/search?q=atlas').set(auth(youssef)).expect(200);
    expect(sites.body.sites).toHaveLength(0); // pas de LOCATIONS view
  });

  it('demandeur : 200 mais aucune famille (aucune permission view)', async () => {
    const res = await http().get('/search?q=atlas').set(auth(karim)).expect(200);
    expect(res.body).toEqual({ workOrders: [], assets: [], sites: [] });
  });

  it('moins de 2 caractères : réponse vide, pas de requête inutile', async () => {
    const res = await http().get('/search?q=a').set(auth(salma)).expect(200);
    expect(res.body).toEqual({ workOrders: [], assets: [], sites: [] });
  });

  it('sans jeton : 401 (API fermée par défaut)', async () => {
    await http().get('/search?q=atlas').expect(401);
  });

  it('tiers : les syndics portent leurs sites (« Rattachements » de la maquette)', async () => {
    const { body } = await http().get('/partners').set(auth(yasmine)).expect(200);
    const atlas = body.partners.find(
      (p: { name: string }) => p.name === 'Atlas Property Management',
    );
    expect(atlas.siteNames).toEqual(['Tour Atlas']);
    const fournisseur = body.partners.find((p: { name: string }) => p.name === 'Lubmaroc');
    expect(fournisseur.siteNames).toEqual([]);
  });

  it('analytics : période 3/6/12 mois, 12 par défaut, valeur inconnue repliée sur 12', async () => {
    const trois = await http().get('/analytics/summary?months=3').set(auth(yasmine)).expect(200);
    expect(trois.body.months).toBe(3);
    expect(trois.body.costsByMonth).toHaveLength(3);

    const defaut = await http().get('/analytics/summary').set(auth(yasmine)).expect(200);
    expect(defaut.body.months).toBe(12);
    expect(defaut.body.costsByMonth).toHaveLength(12);

    const inconnu = await http().get('/analytics/summary?months=7').set(auth(yasmine)).expect(200);
    expect(inconnu.body.months).toBe(12);
  });

  it('sites : le rattachement n’accepte qu’un tiers Client / syndic', async () => {
    const { body: partners } = await http().get('/partners').set(auth(yasmine));
    const fournisseur = partners.partners.find((p: { kind: string }) => p.kind === 'SUPPLIER');
    const { body: locations } = await http().get('/locations').set(auth(yasmine));
    const site = locations.locations.find(
      (l: { parentId: string | null; name: string }) => !l.parentId && l.name === 'Anfa Place',
    );
    await http()
      .patch(`/locations/${site.id}`)
      .set(auth(yasmine))
      .send({ partnerId: fournisseur.id })
      .expect(400);
  });
});