624 lines
18 KiB
JavaScript
624 lines
18 KiB
JavaScript
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;
|
|
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, authorization, body }) =>
|
|
new Promise((resolve, reject) => {
|
|
const rawBody = body ? JSON.stringify(body) : '';
|
|
|
|
const req = http.request(
|
|
{
|
|
hostname: '127.0.0.1',
|
|
port,
|
|
method,
|
|
path,
|
|
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();
|
|
});
|
|
|
|
test.before(() => {
|
|
originalQuery = db.query;
|
|
originalGetConnection = db.getConnection;
|
|
});
|
|
|
|
test.after(() => {
|
|
db.query = originalQuery;
|
|
db.getConnection = originalGetConnection;
|
|
});
|
|
|
|
test.afterEach(() => {
|
|
db.query = originalQuery;
|
|
db.getConnection = originalGetConnection;
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status 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 routeLayer = apiRouterLayers
|
|
.flatMap((routerLayer) => routerLayer.handle.stack)
|
|
.find(
|
|
(layer) =>
|
|
layer.route &&
|
|
layer.route.path === '/trips/:id/auto-status' &&
|
|
layer.route.methods.post
|
|
);
|
|
|
|
assert.ok(routeLayer, 'POST /api/trips/:id/auto-status route is not defined');
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status con id_punto inserta c_cambios_estado y actualiza punto', async () => {
|
|
let txStep = 0;
|
|
let beginCalled = false;
|
|
let commitCalled = false;
|
|
let rollbackCalled = false;
|
|
let releaseCalled = false;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {
|
|
beginCalled = true;
|
|
},
|
|
query: async (sql, params) => {
|
|
txStep += 1;
|
|
|
|
if (/UPDATE c_viajes\s/i.test(sql)) {
|
|
throw new Error('Unexpected update on c_viajes');
|
|
}
|
|
|
|
if (txStep === 1) {
|
|
assert.match(sql, /FROM t_viaje_estados/);
|
|
assert.deepEqual(params, [5]);
|
|
return [[{ id_estado: 5 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
assert.match(sql, /FROM c_viajes/);
|
|
assert.match(sql, /FOR UPDATE/);
|
|
assert.deepEqual(params, [248230]);
|
|
return [[{ id_viaje: 248230 }]];
|
|
}
|
|
|
|
if (txStep === 3) {
|
|
assert.match(sql, /FROM c_viajes_proveedor/);
|
|
assert.match(sql, /FOR UPDATE/);
|
|
assert.deepEqual(params, [248230, '58045340X']);
|
|
return [[{ n_proveedor: 1 }]];
|
|
}
|
|
|
|
if (txStep === 4) {
|
|
assert.match(sql, /INSERT INTO c_cambios_estado/);
|
|
assert.match(sql, /actualizado_automaticamente/);
|
|
assert.equal(params[0], 248230);
|
|
assert.equal(params[1], 1);
|
|
assert.equal(params[2], '58045340X');
|
|
assert.equal(params[3], 5);
|
|
assert.equal(params[4], 1);
|
|
assert.equal(params[5], 'estado automático punto');
|
|
assert.equal(params[6], '40.416775');
|
|
assert.equal(params[7], '-3.70379');
|
|
assert.equal(params[8], '2026-02-17 12:34:56');
|
|
assert.equal(params[11], 1);
|
|
return [{ affectedRows: 1, insertId: 9001 }];
|
|
}
|
|
|
|
if (txStep === 5) {
|
|
assert.match(sql, /FROM c_viajes_puntos/);
|
|
assert.match(sql, /FOR UPDATE/);
|
|
assert.deepEqual(params, [8123, 248230]);
|
|
return [[{ id_punto: 8123 }]];
|
|
}
|
|
|
|
if (txStep === 6) {
|
|
assert.match(sql, /UPDATE c_viajes_puntos/);
|
|
assert.match(sql, /actualizado_automaticamente = 1/);
|
|
assert.deepEqual(params, [5, '2026-02-17 12:34:56', 1, '40.416775', '-3.70379', 8123, 248230]);
|
|
return [{ affectedRows: 1 }];
|
|
}
|
|
|
|
throw new Error(`Unexpected query on step ${txStep}: ${sql}`);
|
|
},
|
|
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/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 5,
|
|
id_punto: 8123,
|
|
observaciones: 'estado automático punto',
|
|
ind_fallido: 1,
|
|
latitud: '40,416775',
|
|
longitud: '-3,70379',
|
|
fecha_y_hora: '2026-02-17 12:34:56'
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 200);
|
|
assert.equal(response.body.success, true);
|
|
assert.equal(response.body.trip_id, 248230);
|
|
assert.equal(response.body.id_estado, 5);
|
|
assert.equal(response.body.id_punto, 8123);
|
|
assert.equal(response.body.actualizado_automaticamente, 1);
|
|
assert.match(response.body.updated_at, /^\d{4}-\d{2}-\d{2}T/);
|
|
assert.equal(beginCalled, true);
|
|
assert.equal(commitCalled, true);
|
|
assert.equal(rollbackCalled, false);
|
|
assert.equal(releaseCalled, true);
|
|
assert.equal(txStep, 6);
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status global inserta c_cambios_estado y no toca puntos', async () => {
|
|
let txStep = 0;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {},
|
|
query: async (sql, params) => {
|
|
txStep += 1;
|
|
|
|
if (/UPDATE c_viajes\s/i.test(sql)) {
|
|
throw new Error('Unexpected update on c_viajes');
|
|
}
|
|
|
|
if (/c_viajes_puntos/i.test(sql)) {
|
|
throw new Error('Point tables should not be touched for global status');
|
|
}
|
|
|
|
if (txStep === 1) {
|
|
assert.match(sql, /FROM t_viaje_estados/);
|
|
assert.deepEqual(params, [7]);
|
|
return [[{ id_estado: 7 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
assert.match(sql, /FROM c_viajes/);
|
|
assert.deepEqual(params, [248230]);
|
|
return [[{ id_viaje: 248230 }]];
|
|
}
|
|
|
|
if (txStep === 3) {
|
|
assert.match(sql, /FROM c_viajes_proveedor/);
|
|
assert.deepEqual(params, [248230, '58045340X']);
|
|
return [[{ n_proveedor: 1 }]];
|
|
}
|
|
|
|
if (txStep === 4) {
|
|
assert.match(sql, /INSERT INTO c_cambios_estado/);
|
|
assert.equal(params[0], 248230);
|
|
assert.equal(params[3], 7);
|
|
assert.equal(params[11], 1);
|
|
return [{ affectedRows: 1, insertId: 9002 }];
|
|
}
|
|
|
|
throw new Error(`Unexpected query on step ${txStep}: ${sql}`);
|
|
},
|
|
commit: async () => {},
|
|
rollback: async () => {
|
|
throw new Error('rollback should not be called for successful request');
|
|
},
|
|
release: () => {}
|
|
};
|
|
|
|
db.getConnection = async () => connection;
|
|
|
|
const response = await withServer(async (server) =>
|
|
requestJson({
|
|
port: server.address().port,
|
|
method: 'POST',
|
|
path: '/api/trips/248230/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 7,
|
|
observaciones: 'estado global automático',
|
|
latitud: '40.1',
|
|
longitud: '-3.7'
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 200);
|
|
assert.equal(response.body.success, true);
|
|
assert.equal(response.body.trip_id, 248230);
|
|
assert.equal(response.body.id_estado, 7);
|
|
assert.equal(response.body.actualizado_automaticamente, 1);
|
|
assert.equal(Object.prototype.hasOwnProperty.call(response.body, 'id_punto'), false);
|
|
assert.equal(txStep, 4);
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status con id_punto y estado no intermedio devuelve 422', async () => {
|
|
db.getConnection = async () => {
|
|
throw new Error('db.getConnection should not run for invalid point status');
|
|
};
|
|
|
|
const response = await withServer(async (server) =>
|
|
requestJson({
|
|
port: server.address().port,
|
|
method: 'POST',
|
|
path: '/api/trips/248230/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 7,
|
|
id_punto: 8123
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 422);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Invalid point status'
|
|
});
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 400 para payload inválido', async () => {
|
|
db.getConnection = async () => {
|
|
throw new Error('db.getConnection should not run for invalid payload');
|
|
};
|
|
|
|
const response = await withServer(async (server) =>
|
|
requestJson({
|
|
port: server.address().port,
|
|
method: 'POST',
|
|
path: '/api/trips/248230/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_punto: 8123
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 400);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Invalid payload'
|
|
});
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 401 sin token', async () => {
|
|
db.getConnection = async () => {
|
|
throw new Error('db.getConnection should not be called without token');
|
|
};
|
|
|
|
const response = await withServer(async (server) =>
|
|
requestJson({
|
|
port: server.address().port,
|
|
method: 'POST',
|
|
path: '/api/trips/248230/auto-status',
|
|
body: {
|
|
id_estado: 5,
|
|
id_punto: 8123
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 401);
|
|
assert.deepEqual(response.body, { error: 'Unauthorized' });
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 403 para viaje no autorizado', async () => {
|
|
let txStep = 0;
|
|
let rollbackCalled = false;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {},
|
|
query: async (sql) => {
|
|
txStep += 1;
|
|
|
|
if (txStep === 1) {
|
|
assert.match(sql, /FROM t_viaje_estados/);
|
|
return [[{ id_estado: 7 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
assert.match(sql, /FROM c_viajes/);
|
|
return [[{ id_viaje: 248230 }]];
|
|
}
|
|
|
|
if (txStep === 3) {
|
|
assert.match(sql, /FROM c_viajes_proveedor/);
|
|
return [[]];
|
|
}
|
|
|
|
throw new Error('No further queries should run for forbidden trip');
|
|
},
|
|
commit: async () => {
|
|
throw new Error('commit should not be called');
|
|
},
|
|
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/auto-status',
|
|
authorization: `Bearer ${createToken({ dni: '00000000T' })}`,
|
|
body: {
|
|
id_estado: 7
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 403);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Forbidden'
|
|
});
|
|
assert.equal(rollbackCalled, true);
|
|
assert.equal(txStep, 3);
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 404 cuando viaje no existe', async () => {
|
|
let txStep = 0;
|
|
let rollbackCalled = false;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {},
|
|
query: async (sql) => {
|
|
txStep += 1;
|
|
|
|
if (txStep === 1) {
|
|
assert.match(sql, /FROM t_viaje_estados/);
|
|
return [[{ id_estado: 7 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
assert.match(sql, /FROM c_viajes/);
|
|
return [[]];
|
|
}
|
|
|
|
throw new Error('Authorization query should not run when trip does not exist');
|
|
},
|
|
commit: async () => {
|
|
throw new Error('commit should not be called');
|
|
},
|
|
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/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 7
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 404);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Trip not found'
|
|
});
|
|
assert.equal(rollbackCalled, true);
|
|
assert.equal(txStep, 2);
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 404 cuando punto no existe', async () => {
|
|
let txStep = 0;
|
|
let rollbackCalled = false;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {},
|
|
query: async (sql) => {
|
|
txStep += 1;
|
|
|
|
if (txStep === 1) {
|
|
return [[{ id_estado: 5 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
return [[{ id_viaje: 248230 }]];
|
|
}
|
|
|
|
if (txStep === 3) {
|
|
return [[{ n_proveedor: 1 }]];
|
|
}
|
|
|
|
if (txStep === 4) {
|
|
assert.match(sql, /INSERT INTO c_cambios_estado/);
|
|
return [{ affectedRows: 1, insertId: 9003 }];
|
|
}
|
|
|
|
if (txStep === 5) {
|
|
assert.match(sql, /FROM c_viajes_puntos/);
|
|
return [[]];
|
|
}
|
|
|
|
throw new Error('Point update should not run when point does not exist');
|
|
},
|
|
commit: async () => {
|
|
throw new Error('commit should not be called');
|
|
},
|
|
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/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 5,
|
|
id_punto: 99999
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 404);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Trip point not found'
|
|
});
|
|
assert.equal(rollbackCalled, true);
|
|
assert.equal(txStep, 5);
|
|
});
|
|
|
|
test('POST /api/trips/:id/auto-status devuelve 500 y hace rollback en error transaccional', async () => {
|
|
let txStep = 0;
|
|
let rollbackCalled = false;
|
|
let releaseCalled = false;
|
|
|
|
const connection = {
|
|
beginTransaction: async () => {},
|
|
query: async (sql) => {
|
|
txStep += 1;
|
|
|
|
if (txStep === 1) {
|
|
return [[{ id_estado: 7 }]];
|
|
}
|
|
|
|
if (txStep === 2) {
|
|
return [[{ id_viaje: 248230 }]];
|
|
}
|
|
|
|
if (txStep === 3) {
|
|
return [[{ n_proveedor: 1 }]];
|
|
}
|
|
|
|
if (txStep === 4) {
|
|
assert.match(sql, /INSERT INTO c_cambios_estado/);
|
|
throw new Error('insert failed');
|
|
}
|
|
|
|
throw new Error('Unexpected query execution');
|
|
},
|
|
commit: async () => {
|
|
throw new Error('commit should not be called after error');
|
|
},
|
|
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/auto-status',
|
|
authorization: `Bearer ${createToken()}`,
|
|
body: {
|
|
id_estado: 7
|
|
}
|
|
})
|
|
);
|
|
|
|
assert.equal(response.statusCode, 500);
|
|
assert.deepEqual(response.body, {
|
|
success: false,
|
|
error: 'Internal server error'
|
|
});
|
|
assert.equal(rollbackCalled, true);
|
|
assert.equal(releaseCalled, true);
|
|
assert.equal(txStep, 4);
|
|
});
|