289 lines
8.3 KiB
TypeScript
289 lines
8.3 KiB
TypeScript
/**
|
|
* @ai-summary Integration tests for vehicles API endpoints
|
|
* @ai-context Tests complete request/response cycle with test database
|
|
*/
|
|
|
|
import request from 'supertest';
|
|
import { app } from '../../../../app';
|
|
import pool from '../../../../core/config/database';
|
|
import { cacheService } from '../../../../core/config/redis';
|
|
import { readFileSync } from 'fs';
|
|
import { join } from 'path';
|
|
|
|
// Mock auth plugin to bypass JWT validation in tests
|
|
jest.mock('../../../../core/plugins/auth.plugin', () => {
|
|
const fastifyPlugin = require('fastify-plugin');
|
|
return {
|
|
default: fastifyPlugin(async function(fastify) {
|
|
fastify.decorate('authenticate', async function(request, _reply) {
|
|
request.user = { sub: 'test-user-123' };
|
|
});
|
|
}, { name: 'auth-plugin' })
|
|
};
|
|
});
|
|
|
|
// Mock external VIN decoder
|
|
jest.mock('../../external/vpic/vpic.client', () => ({
|
|
vpicClient: {
|
|
decodeVIN: jest.fn().mockResolvedValue({
|
|
make: 'Honda',
|
|
model: 'Civic',
|
|
year: 2021,
|
|
engineType: '2.0L',
|
|
bodyType: 'Sedan',
|
|
rawData: []
|
|
})
|
|
}
|
|
}));
|
|
|
|
describe('Vehicles Integration Tests', () => {
|
|
beforeAll(async () => {
|
|
// Run the vehicles migration directly using the migration file
|
|
const migrationFile = join(__dirname, '../../migrations/001_create_vehicles_tables.sql');
|
|
const migrationSQL = readFileSync(migrationFile, 'utf-8');
|
|
await pool.query(migrationSQL);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
// Clean up test database
|
|
await pool.query('DROP TABLE IF EXISTS vehicles CASCADE');
|
|
await pool.query('DROP TABLE IF EXISTS vin_cache CASCADE');
|
|
await pool.query('DROP FUNCTION IF EXISTS update_updated_at_column() CASCADE');
|
|
await pool.end();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
// Clean up test data before each test - more thorough cleanup
|
|
await pool.query('DELETE FROM vehicles WHERE user_id = $1', ['test-user-123']);
|
|
await pool.query('DELETE FROM vin_cache WHERE vin LIKE $1', ['1HGBH41JXMN%']);
|
|
|
|
// Clear Redis cache for the test user
|
|
try {
|
|
await cacheService.del('vehicles:user:test-user-123');
|
|
} catch (error) {
|
|
// Ignore cache cleanup errors in tests
|
|
console.warn('Failed to clear Redis cache in test:', error);
|
|
}
|
|
});
|
|
|
|
describe('POST /api/vehicles', () => {
|
|
it('should create a new vehicle', async () => {
|
|
const vehicleData = {
|
|
vin: '1HGBH41JXMN109186',
|
|
nickname: 'My Test Car',
|
|
color: 'Blue',
|
|
odometerReading: 50000
|
|
};
|
|
|
|
const response = await request(app)
|
|
.post('/api/vehicles')
|
|
.send(vehicleData)
|
|
.expect(201);
|
|
|
|
expect(response.body).toMatchObject({
|
|
id: expect.any(String),
|
|
userId: 'test-user-123',
|
|
vin: '1HGBH41JXMN109186',
|
|
make: 'Honda',
|
|
model: 'Civic',
|
|
year: 2021,
|
|
nickname: 'My Test Car',
|
|
color: 'Blue',
|
|
odometerReading: 50000,
|
|
isActive: true,
|
|
createdAt: expect.any(String),
|
|
updatedAt: expect.any(String)
|
|
});
|
|
});
|
|
|
|
it('should reject invalid VIN', async () => {
|
|
const vehicleData = {
|
|
vin: 'INVALID',
|
|
nickname: 'Test Car'
|
|
};
|
|
|
|
const response = await request(app)
|
|
.post('/api/vehicles')
|
|
.send(vehicleData)
|
|
.expect(400);
|
|
|
|
expect(response.body.error).toMatch(/VIN/);
|
|
});
|
|
|
|
it('should reject duplicate VIN for same user', async () => {
|
|
const vehicleData = {
|
|
vin: '1HGBH41JXMN109186',
|
|
nickname: 'First Car'
|
|
};
|
|
|
|
// Create first vehicle
|
|
await request(app)
|
|
.post('/api/vehicles')
|
|
.send(vehicleData)
|
|
.expect(201);
|
|
|
|
// Try to create duplicate
|
|
const response = await request(app)
|
|
.post('/api/vehicles')
|
|
.send({ ...vehicleData, nickname: 'Duplicate Car' })
|
|
.expect(400);
|
|
|
|
expect(response.body.error).toBe('Vehicle with this VIN already exists');
|
|
});
|
|
});
|
|
|
|
describe('GET /api/vehicles', () => {
|
|
it('should return user vehicles', async () => {
|
|
// Create test vehicles
|
|
await pool.query(`
|
|
INSERT INTO vehicles (user_id, vin, make, model, year, nickname)
|
|
VALUES
|
|
($1, $2, $3, $4, $5, $6),
|
|
($7, $8, $9, $10, $11, $12)
|
|
`, [
|
|
'test-user-123', '1HGBH41JXMN109186', 'Honda', 'Civic', 2021, 'Car 1',
|
|
'test-user-123', '1HGBH41JXMN109187', 'Toyota', 'Camry', 2020, 'Car 2'
|
|
]);
|
|
|
|
const response = await request(app)
|
|
.get('/api/vehicles')
|
|
.expect(200);
|
|
|
|
expect(response.body).toHaveLength(2);
|
|
expect(response.body[0]).toMatchObject({
|
|
userId: 'test-user-123',
|
|
vin: expect.any(String),
|
|
nickname: expect.any(String)
|
|
});
|
|
});
|
|
|
|
it('should return empty array for user with no vehicles', async () => {
|
|
const response = await request(app)
|
|
.get('/api/vehicles')
|
|
.expect(200);
|
|
|
|
expect(response.body).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('GET /api/vehicles/:id', () => {
|
|
it('should return specific vehicle', async () => {
|
|
// Create test vehicle
|
|
const result = await pool.query(`
|
|
INSERT INTO vehicles (user_id, vin, make, model, year, nickname)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING id
|
|
`, ['test-user-123', '1HGBH41JXMN109186', 'Honda', 'Civic', 2021, 'Test Car']);
|
|
|
|
const vehicleId = result.rows[0].id;
|
|
|
|
const response = await request(app)
|
|
.get(`/api/vehicles/${vehicleId}`)
|
|
.expect(200);
|
|
|
|
expect(response.body).toMatchObject({
|
|
id: vehicleId,
|
|
userId: 'test-user-123',
|
|
vin: '1HGBH41JXMN109186',
|
|
make: 'Honda',
|
|
nickname: 'Test Car'
|
|
});
|
|
});
|
|
|
|
it('should return 404 for non-existent vehicle', async () => {
|
|
const fakeId = '550e8400-e29b-41d4-a716-446655440000';
|
|
|
|
const response = await request(app)
|
|
.get(`/api/vehicles/${fakeId}`)
|
|
.expect(404);
|
|
|
|
expect(response.body.error).toBe('Vehicle not found');
|
|
});
|
|
|
|
it('should return 400 for invalid UUID format', async () => {
|
|
const response = await request(app)
|
|
.get('/api/vehicles/invalid-id')
|
|
.expect(400);
|
|
|
|
expect(response.body).toHaveProperty('error');
|
|
});
|
|
});
|
|
|
|
describe('PUT /api/vehicles/:id', () => {
|
|
it('should update vehicle', async () => {
|
|
// Create test vehicle
|
|
const result = await pool.query(`
|
|
INSERT INTO vehicles (user_id, vin, nickname, color)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING id
|
|
`, ['test-user-123', '1HGBH41JXMN109186', 'Old Name', 'Blue']);
|
|
|
|
const vehicleId = result.rows[0].id;
|
|
|
|
const updateData = {
|
|
nickname: 'Updated Name',
|
|
color: 'Red',
|
|
odometerReading: 75000
|
|
};
|
|
|
|
const response = await request(app)
|
|
.put(`/api/vehicles/${vehicleId}`)
|
|
.send(updateData)
|
|
.expect(200);
|
|
|
|
expect(response.body).toMatchObject({
|
|
id: vehicleId,
|
|
nickname: 'Updated Name',
|
|
color: 'Red',
|
|
odometerReading: 75000
|
|
});
|
|
});
|
|
|
|
it('should return 404 for non-existent vehicle', async () => {
|
|
const fakeId = '550e8400-e29b-41d4-a716-446655440000';
|
|
|
|
const response = await request(app)
|
|
.put(`/api/vehicles/${fakeId}`)
|
|
.send({ nickname: 'Updated' })
|
|
.expect(404);
|
|
|
|
expect(response.body.error).toBe('Vehicle not found');
|
|
});
|
|
});
|
|
|
|
describe('DELETE /api/vehicles/:id', () => {
|
|
it('should soft delete vehicle', async () => {
|
|
// Create test vehicle
|
|
const result = await pool.query(`
|
|
INSERT INTO vehicles (user_id, vin, nickname)
|
|
VALUES ($1, $2, $3)
|
|
RETURNING id
|
|
`, ['test-user-123', '1HGBH41JXMN109186', 'Test Car']);
|
|
|
|
const vehicleId = result.rows[0].id;
|
|
|
|
await request(app)
|
|
.delete(`/api/vehicles/${vehicleId}`)
|
|
.expect(204);
|
|
|
|
// Verify vehicle is soft deleted
|
|
const checkResult = await pool.query(
|
|
'SELECT is_active, deleted_at FROM vehicles WHERE id = $1',
|
|
[vehicleId]
|
|
);
|
|
|
|
expect(checkResult.rows[0].is_active).toBe(false);
|
|
expect(checkResult.rows[0].deleted_at).toBeTruthy();
|
|
});
|
|
|
|
it('should return 404 for non-existent vehicle', async () => {
|
|
const fakeId = '550e8400-e29b-41d4-a716-446655440000';
|
|
|
|
const response = await request(app)
|
|
.delete(`/api/vehicles/${fakeId}`)
|
|
.expect(404);
|
|
|
|
expect(response.body.error).toBe('Vehicle not found');
|
|
});
|
|
});
|
|
}); |