Fix passenger startup and clean tracked generated files

test/trips.list.integration.test.js

@@ -0,0 +1,236 @@
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const test = require('node:test');
+const jwt = require('jsonwebtoken');
+
+const app = require('../app');
+const db = require('../src/config/db');
+
+const JWT_SECRET = process.env.JWT_SECRET || 'test-jwt-secret';
+process.env.JWT_SECRET = JWT_SECRET;
+
+let originalQuery;
+
+const createToken = (payload = {}) =>
+    jwt.sign(
+        {
+            id: 1,
+            dni: '58045340X',
+            id_proveedor: 675,
+            ...payload
+        },
+        JWT_SECRET,
+        { expiresIn: '1h' }
+    );
+
+const withServer = async (callback) =>
+    new Promise((resolve, reject) => {
+        const server = app.listen(0, '127.0.0.1');
+
+        server.on('error', reject);
+        server.on('listening', async () => {
+            try {
+                const result = await callback(server);
+                server.close((closeError) => {
+                    if (closeError) {
+                        reject(closeError);
+                        return;
+                    }
+                    resolve(result);
+                });
+            } catch (error) {
+                server.close(() => reject(error));
+            }
+        });
+    });
+
+const requestJson = async ({ port, path, authorization }) =>
+    new Promise((resolve, reject) => {
+        const req = http.request(
+            {
+                hostname: '127.0.0.1',
+                port,
+                method: 'GET',
+                path,
+                headers: authorization ? { authorization } : {}
+            },
+            (res) => {
+                let rawBody = '';
+
+                res.on('data', (chunk) => {
+                    rawBody += chunk;
+                });
+
+                res.on('end', () => {
+                    const body = rawBody ? JSON.parse(rawBody) : null;
+                    resolve({ statusCode: res.statusCode, body });
+                });
+            }
+        );
+
+        req.on('error', reject);
+        req.end();
+    });
+
+test.before(() => {
+    originalQuery = db.query;
+});
+
+test.after(() => {
+    db.query = originalQuery;
+});
+
+test('GET /api/trips está registrado en /api', () => {
+    const apiRouterLayers = app._router.stack.filter(
+        (layer) =>
+            layer.name === 'router' &&
+            layer.regexp &&
+            layer.regexp.toString().includes('^\\/api\\/?(?=\\/|$)')
+    );
+
+    assert.ok(apiRouterLayers.length > 0, 'Router /api is not mounted');
+
+    const tripsRouteLayer = apiRouterLayers
+        .flatMap((routerLayer) => routerLayer.handle.stack)
+        .find(
+            (layer) =>
+                layer.route &&
+                layer.route.path === '/trips' &&
+                layer.route.methods.get
+        );
+
+    assert.ok(tripsRouteLayer, 'GET /api/trips route is not defined');
+});
+
+test('GET /api/trips devuelve viajes del transportista autenticado con aliases legacy', async () => {
+    const mockedTrips = [
+        {
+            id_viaje: 84919,
+            cod_viaje: 'VIA-2026-0001',
+            id_estado: 7,
+            nombrea: 'Barcelona, ES',
+            nombreb: 'Lyon, FR',
+            fecha_salida: '2026-01-22 06:00:00',
+            fecha_llegada: '2026-01-22 18:11:00'
+        },
+        {
+            id_viaje: 84918,
+            cod_viaje: 'VIA-2026-0000',
+            id_estado: 4,
+            nombrea: 'Madrid, ES',
+            nombreb: 'Bilbao, ES',
+            fecha_salida: '2026-01-21',
+            fecha_llegada: '2026-01-21'
+        }
+    ];
+
+    db.query = async (sql, params) => {
+        assert.match(sql, /FROM c_viajes_proveedor p/);
+        assert.match(sql, /INNER JOIN c_viajes v/);
+        assert.match(sql, /INNER JOIN m_proveedores_trasportistas t/);
+        assert.match(sql, /id_estado IN \(\?, \?, \?\)/);
+        assert.match(sql, /AS id_viaje/);
+        assert.match(sql, /AS id_estado/);
+        assert.match(sql, /AS nombrea/);
+        assert.match(sql, /AS nombreb/);
+        assert.match(sql, /AS fecha_salida/);
+        assert.match(sql, /AS fecha_llegada/);
+        assert.deepEqual(params, ['58045340X', 7, 8, 9]);
+        return [mockedTrips];
+    };
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            path: '/api/trips',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 200);
+    assert.deepEqual(response.body, {
+        trips: mockedTrips
+    });
+    assert.equal(response.body.trips[0].id_estado, 7);
+});
+
+test('GET /api/trips devuelve lista vacia cuando no hay viajes', async () => {
+    db.query = async () => [[]];
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            path: '/api/trips',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 200);
+    assert.deepEqual(response.body, {
+        trips: []
+    });
+});
+
+test('GET /api/trips responde en menos de 1s para 500 viajes mockeados', async () => {
+    const mockedTrips = Array.from({ length: 500 }, (_, index) => ({
+        id_viaje: 100000 + index,
+        cod_viaje: `VIA-2026-${String(index + 1).padStart(4, '0')}`,
+        id_estado: index % 2 === 0 ? 7 : 4,
+        nombrea: `ORIGEN ${index + 1}`,
+        nombreb: `DESTINO ${index + 1}`,
+        fecha_salida: '2026-01-22 06:00:00',
+        fecha_llegada: '2026-01-22 18:11:00'
+    }));
+
+    db.query = async () => [mockedTrips];
+
+    const startedAt = Date.now();
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            path: '/api/trips',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+    const elapsedMs = Date.now() - startedAt;
+
+    assert.equal(response.statusCode, 200);
+    assert.equal(response.body.trips.length, 500);
+    assert.ok(elapsedMs < 1000, `Expected < 1000ms, got ${elapsedMs}ms`);
+});
+
+test('GET /api/trips devuelve 401 sin token', async () => {
+    db.query = async () => {
+        throw new Error('db.query should not be called without token');
+    };
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            path: '/api/trips'
+        })
+    );
+
+    assert.equal(response.statusCode, 401);
+    assert.deepEqual(response.body, { error: 'Unauthorized' });
+});
+
+test('GET /api/trips devuelve 500 en error interno', async () => {
+    db.query = async () => {
+        throw new Error('forced db failure');
+    };
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            path: '/api/trips',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 500);
+    assert.deepEqual(response.body, {
+        success: false,
+        error: 'Internal server error'
+    });
+});