Fix passenger startup and clean tracked generated files

2026-03-31 15:14:12 +02:00
parent c1b9fe666b
commit 5385841a62
5908 changed files with 15305 additions and 872091 deletions
@@ -0,0 +1,610 @@
+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 originalGetConnection;
+
+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, method, path: requestPath, authorization, body }) =>
+    new Promise((resolve, reject) => {
+        const rawBody = body ? JSON.stringify(body) : '';
+
+        const req = http.request(
+            {
+                hostname: '127.0.0.1',
+                port,
+                method,
+                path: requestPath,
+                headers: {
+                    ...(authorization ? { authorization } : {}),
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(rawBody)
+                }
+            },
+            (res) => {
+                let responseBody = '';
+
+                res.on('data', (chunk) => {
+                    responseBody += chunk;
+                });
+
+                res.on('end', () => {
+                    resolve({
+                        statusCode: res.statusCode,
+                        body: responseBody ? JSON.parse(responseBody) : null
+                    });
+                });
+            }
+        );
+
+        req.on('error', reject);
+        req.write(rawBody);
+        req.end();
+    });
+
+const formatSqlDateTime = (date) => {
+    const value = date instanceof Date ? date : new Date(date);
+    return value.toISOString().slice(0, 19).replace('T', ' ');
+};
+
+test.before(() => {
+    originalGetConnection = db.getConnection;
+});
+
+test.after(() => {
+    db.getConnection = originalGetConnection;
+});
+
+test('POST /api/trips/:tripId/start 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 startRouteLayer = apiRouterLayers
+        .flatMap((routerLayer) => routerLayer.handle.stack)
+        .find(
+            (layer) =>
+                layer.route &&
+                layer.route.path === '/trips/:tripId/start' &&
+                layer.route.methods.post
+        );
+
+    assert.ok(startRouteLayer, 'POST /api/trips/:tripId/start route is not defined');
+});
+
+test('POST /api/trips/:tripId/start inicia viaje asignado sin otro activo => 200', async () => {
+    let step = 0;
+    let beginCalled = false;
+    let commitCalled = false;
+    let rollbackCalled = false;
+    let releaseCalled = false;
+
+    const connection = {
+        beginTransaction: async () => {
+            beginCalled = true;
+        },
+        query: async (sql, params) => {
+            step += 1;
+
+            if (step === 1) {
+                assert.match(sql, /FROM c_viajes_proveedor/);
+                assert.match(sql, /WHERE dni = \?/);
+                assert.match(sql, /FOR UPDATE/);
+                assert.deepEqual(params, ['58045340X']);
+                return [[{ id_viaje: 248230 }]];
+            }
+
+            if (step === 2) {
+                assert.match(sql, /FROM c_viajes/);
+                assert.match(sql, /WHERE id_viaje = \?/);
+                assert.match(sql, /FOR UPDATE/);
+                assert.deepEqual(params, [248230]);
+                return [[{ id_viaje: 248230, cod_viaje: 'VIA-2026-0001', id_estado: 1 }]];
+            }
+
+            if (step === 3) {
+                assert.match(sql, /FROM c_viajes_proveedor/);
+                assert.match(sql, /AND dni = \?/);
+                assert.match(sql, /FOR UPDATE/);
+                assert.deepEqual(params, [248230, '58045340X']);
+                return [[{ n_proveedor: 1 }]];
+            }
+
+            if (step === 4) {
+                assert.match(sql, /INNER JOIN c_viajes v/);
+                assert.match(sql, /id_estado BETWEEN \? AND \?/);
+                assert.match(sql, /FOR UPDATE/);
+                assert.deepEqual(params, ['58045340X', 248230, 2, 6]);
+                return [[]];
+            }
+
+            if (step === 5) {
+                assert.match(sql, /UPDATE c_viajes/);
+                assert.equal(params[0], 2);
+                assert.ok(params[1] instanceof Date);
+                assert.equal(params[2], 1);
+                assert.equal(params[3], 248230);
+                return [{ affectedRows: 1 }];
+            }
+
+            if (step === 6) {
+                assert.match(sql, /INSERT INTO c_cambios_estado/);
+                assert.equal(params[0], 248230);
+                assert.equal(params[1], 1);
+                assert.equal(params[2], '58045340X');
+                assert.equal(params[3], 2);
+                assert.ok(params[7] instanceof Date);
+                assert.equal(params[9], 1);
+                return [{ insertId: 10, affectedRows: 1 }];
+            }
+
+            assert.match(sql, /SELECT/);
+            assert.match(sql, /fecha_inicio_real/);
+            assert.deepEqual(params, [248230]);
+            return [[{
+                id_viaje: 248230,
+                cod_viaje: 'VIA-2026-0001',
+                id_estado: 2,
+                fecha_inicio_real: '2026-02-11 12:30:00'
+            }]];
+        },
+        commit: async () => {
+            commitCalled = true;
+        },
+        rollback: async () => {
+            rollbackCalled = true;
+        },
+        release: () => {
+            releaseCalled = true;
+        }
+    };
+
+    db.getConnection = async () => connection;
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/248230/start',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 200);
+    assert.deepEqual(response.body, {
+        success: true,
+        trip: {
+            id_viaje: 248230,
+            cod_viaje: 'VIA-2026-0001',
+            id_estado: 2,
+            fecha_inicio_real: '2026-02-11 12:30:00'
+        }
+    });
+    assert.equal(beginCalled, true);
+    assert.equal(commitCalled, true);
+    assert.equal(rollbackCalled, false);
+    assert.equal(releaseCalled, true);
+    assert.equal(step, 7);
+});
+
+test('POST /api/trips/:tripId/start devuelve 409 ACTIVE_TRIP_EXISTS si hay otro viaje en curso', async () => {
+    let step = 0;
+    let rollbackCalled = false;
+
+    const connection = {
+        beginTransaction: async () => {},
+        query: async (_sql, _params) => {
+            step += 1;
+
+            if (step === 1) {
+                return [[{ id_viaje: 248230 }]];
+            }
+
+            if (step === 2) {
+                return [[{ id_viaje: 248230, cod_viaje: 'VIA-2026-0001', id_estado: 1 }]];
+            }
+
+            if (step === 3) {
+                return [[{ n_proveedor: 1 }]];
+            }
+
+            return [[{ id_viaje: 248231, cod_viaje: 'VIA-2026-0002', id_estado: 4 }]];
+        },
+        commit: async () => {
+            throw new Error('commit should not run for conflict');
+        },
+        rollback: async () => {
+            rollbackCalled = true;
+        },
+        release: () => {}
+    };
+
+    db.getConnection = async () => connection;
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/248230/start',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 409);
+    assert.deepEqual(response.body, {
+        success: false,
+        code: 'ACTIVE_TRIP_EXISTS',
+        message: 'Ya existe un viaje en curso',
+        activeTrip: {
+            id_viaje: 248231,
+            cod_viaje: 'VIA-2026-0002',
+            id_estado: 4
+        }
+    });
+    assert.equal(rollbackCalled, true);
+    assert.equal(step, 4);
+});
+
+test('POST /api/trips/:tripId/start devuelve 422 cuando el viaje no está asignado', async () => {
+    let step = 0;
+    let rollbackCalled = false;
+
+    const connection = {
+        beginTransaction: async () => {},
+        query: async () => {
+            step += 1;
+
+            if (step === 1) {
+                return [[{ id_viaje: 248230 }]];
+            }
+
+            if (step === 2) {
+                return [[{ id_viaje: 248230, cod_viaje: 'VIA-2026-0001', id_estado: 5 }]];
+            }
+
+            return [[{ n_proveedor: 1 }]];
+        },
+        commit: async () => {
+            throw new Error('commit should not run for invalid status');
+        },
+        rollback: async () => {
+            rollbackCalled = true;
+        },
+        release: () => {}
+    };
+
+    db.getConnection = async () => connection;
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/248230/start',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 422);
+    assert.deepEqual(response.body, {
+        success: false,
+        code: 'INVALID_STATUS',
+        message: 'El viaje no está en estado asignado'
+    });
+    assert.equal(rollbackCalled, true);
+    assert.equal(step, 3);
+});
+
+test('POST /api/trips/:tripId/start devuelve 403 si el viaje no pertenece al usuario', async () => {
+    let step = 0;
+    let rollbackCalled = false;
+
+    const connection = {
+        beginTransaction: async () => {},
+        query: async () => {
+            step += 1;
+
+            if (step === 1) {
+                return [[{ id_viaje: 248230 }]];
+            }
+
+            if (step === 2) {
+                return [[{ id_viaje: 248230, cod_viaje: 'VIA-2026-0001', id_estado: 1 }]];
+            }
+
+            return [[]];
+        },
+        commit: async () => {
+            throw new Error('commit should not run for forbidden');
+        },
+        rollback: async () => {
+            rollbackCalled = true;
+        },
+        release: () => {}
+    };
+
+    db.getConnection = async () => connection;
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/248230/start',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 403);
+    assert.deepEqual(response.body, {
+        success: false,
+        error: 'Forbidden'
+    });
+    assert.equal(rollbackCalled, true);
+    assert.equal(step, 3);
+});
+
+test('POST /api/trips/:tripId/start devuelve 404 cuando el viaje no existe', async () => {
+    let step = 0;
+    let rollbackCalled = false;
+
+    const connection = {
+        beginTransaction: async () => {},
+        query: async () => {
+            step += 1;
+
+            if (step === 1) {
+                return [[{ id_viaje: 248230 }]];
+            }
+
+            return [[]];
+        },
+        commit: async () => {
+            throw new Error('commit should not run for missing trip');
+        },
+        rollback: async () => {
+            rollbackCalled = true;
+        },
+        release: () => {}
+    };
+
+    db.getConnection = async () => connection;
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/99999999/start',
+            authorization: `Bearer ${createToken()}`
+        })
+    );
+
+    assert.equal(response.statusCode, 404);
+    assert.deepEqual(response.body, {
+        success: false,
+        error: 'Trip not found'
+    });
+    assert.equal(rollbackCalled, true);
+    assert.equal(step, 2);
+});
+
+test('POST /api/trips/:tripId/start devuelve 401 sin token', async () => {
+    db.getConnection = async () => {
+        throw new Error('db.getConnection should not run without token');
+    };
+
+    const response = await withServer(async (server) =>
+        requestJson({
+            port: server.address().port,
+            method: 'POST',
+            path: '/api/trips/248230/start'
+        })
+    );
+
+    assert.equal(response.statusCode, 401);
+    assert.deepEqual(response.body, { error: 'Unauthorized' });
+});
+
+test('POST /api/trips/:tripId/start serializa inicios simultáneos y evita dos viajes activos', async () => {
+    const trips = new Map([
+        [31001, { id_viaje: 31001, cod_viaje: 'VIA-2026-31001', id_estado: 1, fecha_inicio_real: null }],
+        [31002, { id_viaje: 31002, cod_viaje: 'VIA-2026-31002', id_estado: 1, fecha_inicio_real: null }]
+    ]);
+    const providerTripIds = [31001, 31002];
+    const providerLock = {
+        locked: false,
+        waiters: []
+    };
+    let commitCount = 0;
+    let rollbackCount = 0;
+
+    const acquireProviderLock = async () => {
+        if (!providerLock.locked) {
+            providerLock.locked = true;
+            return;
+        }
+
+        await new Promise((resolve) => {
+            providerLock.waiters.push(resolve);
+        });
+    };
+
+    const releaseProviderLock = () => {
+        if (providerLock.waiters.length > 0) {
+            const next = providerLock.waiters.shift();
+            next();
+            return;
+        }
+
+        providerLock.locked = false;
+    };
+
+    db.getConnection = async () => {
+        let hasProviderLock = false;
+
+        return {
+            beginTransaction: async () => {},
+            query: async (sql, params) => {
+                if (sql.includes('FROM c_viajes_proveedor') && sql.includes('WHERE dni = ?') && sql.includes('ORDER BY id_viaje ASC') && sql.includes('FOR UPDATE')) {
+                    await acquireProviderLock();
+                    hasProviderLock = true;
+                    return [providerTripIds.map((id_viaje) => ({ id_viaje }))];
+                }
+
+                if (sql.includes('FROM c_viajes') && sql.includes('WHERE id_viaje = ?') && sql.includes('FOR UPDATE')) {
+                    const trip = trips.get(params[0]);
+                    return [trip ? [{
+                        id_viaje: trip.id_viaje,
+                        cod_viaje: trip.cod_viaje,
+                        id_estado: trip.id_estado
+                    }] : []];
+                }
+
+                if (sql.includes('FROM c_viajes_proveedor') && sql.includes('AND dni = ?') && sql.includes('LIMIT 1') && sql.includes('FOR UPDATE')) {
+                    const trip = trips.get(params[0]);
+                    return [trip ? [{ n_proveedor: 1 }] : []];
+                }
+
+                if (sql.includes('INNER JOIN c_viajes v') && sql.includes('id_estado BETWEEN ? AND ?') && sql.includes('FOR UPDATE')) {
+                    const requestedTripId = params[1];
+                    const activeTrip = Array.from(trips.values()).find(
+                        (trip) =>
+                            trip.id_viaje !== requestedTripId &&
+                            trip.id_estado >= 2 &&
+                            trip.id_estado <= 6
+                    );
+
+                    if (!activeTrip) {
+                        return [[]];
+                    }
+
+                    return [[{
+                        id_viaje: activeTrip.id_viaje,
+                        cod_viaje: activeTrip.cod_viaje,
+                        id_estado: activeTrip.id_estado
+                    }]];
+                }
+
+                if (sql.includes('UPDATE c_viajes')) {
+                    const trip = trips.get(params[3]);
+                    trip.id_estado = params[0];
+                    trip.fecha_inicio_real = params[1];
+                    return [{ affectedRows: 1 }];
+                }
+
+                if (sql.includes('INSERT INTO c_cambios_estado')) {
+                    return [{ insertId: 99, affectedRows: 1 }];
+                }
+
+                if (sql.includes('DATE_FORMAT(fecha_inicio_real')) {
+                    const trip = trips.get(params[0]);
+                    return [[{
+                        id_viaje: trip.id_viaje,
+                        cod_viaje: trip.cod_viaje,
+                        id_estado: trip.id_estado,
+                        fecha_inicio_real: formatSqlDateTime(trip.fecha_inicio_real)
+                    }]];
+                }
+
+                throw new Error(`Unexpected SQL in concurrency test: ${sql}`);
+            },
+            commit: async () => {
+                commitCount += 1;
+                if (hasProviderLock) {
+                    hasProviderLock = false;
+                    releaseProviderLock();
+                }
+            },
+            rollback: async () => {
+                rollbackCount += 1;
+                if (hasProviderLock) {
+                    hasProviderLock = false;
+                    releaseProviderLock();
+                }
+            },
+            release: () => {
+                if (hasProviderLock) {
+                    hasProviderLock = false;
+                    releaseProviderLock();
+                }
+            }
+        };
+    };
+
+    const [responseA, responseB] = await withServer(async (server) =>
+        Promise.all([
+            requestJson({
+                port: server.address().port,
+                method: 'POST',
+                path: '/api/trips/31001/start',
+                authorization: `Bearer ${createToken()}`
+            }),
+            requestJson({
+                port: server.address().port,
+                method: 'POST',
+                path: '/api/trips/31002/start',
+                authorization: `Bearer ${createToken()}`
+            })
+        ])
+    );
+
+    const statusCodes = [responseA.statusCode, responseB.statusCode].sort((a, b) => a - b);
+    assert.deepEqual(statusCodes, [200, 409]);
+
+    const successResponse = responseA.statusCode === 200 ? responseA : responseB;
+    const conflictResponse = responseA.statusCode === 409 ? responseA : responseB;
+
+    assert.equal(successResponse.body.success, true);
+    assert.equal(conflictResponse.body.success, false);
+    assert.equal(conflictResponse.body.code, 'ACTIVE_TRIP_EXISTS');
+    assert.equal(conflictResponse.body.activeTrip.id_viaje, successResponse.body.trip.id_viaje);
+
+    const activeTrips = Array.from(trips.values()).filter(
+        (trip) => trip.id_estado >= 2 && trip.id_estado <= 6
+    );
+    assert.equal(activeTrips.length, 1);
+    assert.equal(commitCount, 1);
+    assert.equal(rollbackCount, 1);
+});