Luncher/server/src/tests/devRoutes.test.ts

import express from 'express';
import request from 'supertest';
import bodyParser from 'body-parser';
import { generateToken } from '../auth';
import { resetMemoryStorage } from '../storage/memory';
import getStorage from '../storage';
import devRouter from '../routes/devRoutes';
import { createGroup } from '../groups';
import { ClientData, Store } from '../../../types/gen/types.gen';
import { formatDate } from '../utils';
import { getToday } from '../service';

// Websocket v testech neexistuje – broadcast jen odchytíme
jest.mock('../websocket', () => ({
    getWebsocket: () => ({ emit: jest.fn() }),
    emitToUser: jest.fn(),
}));

const storage = getStorage();
const TOKEN = `Bearer ${generateToken('testuser')}`;

function buildApp() {
    const app = express();
    app.use(bodyParser.json());
    app.use('/api/dev', devRouter);
    app.use((err: any, _req: any, res: any, _next: any) => {
        res.status(400).json({ error: err.message });
    });
    return app;
}

/** Vrátí uložená data sekce Objednání pro dnešní den. */
async function getExtra(): Promise<ClientData | undefined> {
    return storage.getData<ClientData>(`${formatDate(getToday())}_extra`);
}

async function setStores(stores: Store[]) {
    await storage.setData('stores', stores);
}

beforeEach(() => {
    resetMemoryStorage();
});

test('POST /dev/generateOrders bez nadefinovaného obchodu vrátí 400', async () => {
    const res = await request(buildApp())
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({});
    expect(res.status).toBe(400);
});

test('POST /dev/generateOrders bez existující skupiny založí jednu a doplní do ní osoby', async () => {
    await setStores([{ name: 'Bistro', urls: ['https://example.com/bistro'] }]);

    const res = await request(buildApp())
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({ count: 4, minAmount: 100, maxAmount: 1000 });

    expect(res.status).toBe(200);
    expect(res.body.count).toBe(4);
    expect(res.body.groups).toHaveLength(1);
    expect(res.body.groups[0].created).toBe(true);

    const data = await getExtra();
    const group = data?.groups?.[0];
    expect(group?.name).toBe('Bistro');
    expect(group?.url).toBe('https://example.com/bistro');
    // Zakladatel (přihlášený uživatel) + 4 doplněné osoby
    const members = Object.entries(group!.members);
    expect(members).toHaveLength(5);
    const mockMembers = members.filter(([login]) => login !== 'testuser');
    expect(mockMembers).toHaveLength(4);
    for (const [, member] of mockMembers) {
        expect(member.amount).toBeGreaterThanOrEqual(100 * 100);
        expect(member.amount).toBeLessThanOrEqual(1000 * 100);
        expect(member.note).toBeTruthy();
    }
});

test('POST /dev/generateOrders doplní osoby do všech existujících skupin', async () => {
    await setStores([{ name: 'Bistro' }, { name: 'Pizzerie' }]);
    await createGroup('testuser', 'Bistro');
    await createGroup('kolega', 'Pizzerie');

    const res = await request(buildApp())
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({ count: 2 });

    expect(res.status).toBe(200);
    expect(res.body.count).toBe(4);
    expect(res.body.groups).toHaveLength(2);
    expect(res.body.groups.every((g: any) => g.created === undefined)).toBe(true);

    const data = await getExtra();
    expect(data?.groups).toHaveLength(2);
    for (const group of data!.groups!) {
        // Zakladatel + 2 doplněné osoby
        expect(Object.keys(group.members)).toHaveLength(3);
    }
});

test('POST /dev/generateOrders použije výchozí hodnoty, když nejsou zadány', async () => {
    await setStores([{ name: 'Bistro' }]);

    const res = await request(buildApp())
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({});

    expect(res.status).toBe(200);
    // Výchozí počet osob je 3
    expect(res.body.count).toBe(3);

    const data = await getExtra();
    for (const [login, member] of Object.entries(data!.groups![0].members)) {
        if (login === 'testuser') continue;
        // Výchozí rozsah částek je 100–1000 Kč
        expect(member.amount).toBeGreaterThanOrEqual(100 * 100);
        expect(member.amount).toBeLessThanOrEqual(1000 * 100);
    }
});

test('POST /dev/generateOrders zvládne počet osob přesahující seznam jmen', async () => {
    await setStores([{ name: 'Bistro' }]);

    const res = await request(buildApp())
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({ count: 50 });

    expect(res.status).toBe(200);
    expect(res.body.count).toBe(50);

    const data = await getExtra();
    // Všechna jména musí být unikátní (zakladatel + 50 doplněných osob)
    expect(Object.keys(data!.groups![0].members)).toHaveLength(51);
});

test('POST /dev/generateOrders odmítne neplatný počet osob a rozsah částek', async () => {
    await setStores([{ name: 'Bistro' }]);
    const app = buildApp();

    const badCount = await request(app)
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({ count: 0 });
    expect(badCount.status).toBe(400);

    const badRange = await request(app)
        .post('/api/dev/generateOrders')
        .set('Authorization', TOKEN)
        .send({ minAmount: 500, maxAmount: 100 });
    expect(badRange.status).toBe(400);
});