590 lines
19 KiB
JavaScript
590 lines
19 KiB
JavaScript
const { describe, it, beforeEach, afterEach, before, after } = require('mocha');
|
|
const { expect } = require('chai');
|
|
const sinon = require('sinon');
|
|
const request = require('supertest');
|
|
const express = require('express');
|
|
const { setupTestEnvironment, teardownTestEnvironment, cleanDatabase, createTestUser, createTestTenant, createTestDevice, generateTestToken } = require('../setup');
|
|
|
|
describe('Healthcheck Routes', () => {
|
|
let app, models, sequelize;
|
|
|
|
before(async () => {
|
|
({ models, sequelize } = await setupTestEnvironment());
|
|
|
|
// Setup express app for testing
|
|
app = express();
|
|
app.use(express.json());
|
|
|
|
// Mock authentication middleware for protected routes
|
|
app.use((req, res, next) => {
|
|
if (req.headers.authorization) {
|
|
const token = req.headers.authorization.replace('Bearer ', '');
|
|
try {
|
|
const jwt = require('jsonwebtoken');
|
|
const decoded = jwt.verify(token, process.env.JWT_SECRET || 'test-secret');
|
|
req.user = { id: decoded.userId, tenant_id: decoded.tenantId };
|
|
req.tenant = { id: decoded.tenantId };
|
|
} catch (error) {
|
|
return res.status(401).json({ success: false, message: 'Invalid token' });
|
|
}
|
|
}
|
|
next();
|
|
});
|
|
|
|
// Setup healthcheck routes
|
|
const healthRoutes = require('../../routes/health');
|
|
app.use('/health', healthRoutes);
|
|
});
|
|
|
|
after(async () => {
|
|
await teardownTestEnvironment();
|
|
});
|
|
|
|
beforeEach(async () => {
|
|
await cleanDatabase();
|
|
});
|
|
|
|
describe('GET /health', () => {
|
|
it('should return basic health status', async () => {
|
|
const response = await request(app)
|
|
.get('/health');
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.status).to.equal('ok');
|
|
expect(response.body.timestamp).to.exist;
|
|
expect(response.body.uptime).to.be.a('number');
|
|
});
|
|
|
|
it('should include service version information', async () => {
|
|
const response = await request(app)
|
|
.get('/health');
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.version).to.exist;
|
|
expect(response.body.service).to.equal('UAM-ILS Drone Detection System');
|
|
});
|
|
|
|
it('should return health status quickly', async () => {
|
|
const startTime = Date.now();
|
|
|
|
const response = await request(app)
|
|
.get('/health');
|
|
|
|
const responseTime = Date.now() - startTime;
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(responseTime).to.be.lessThan(1000); // Should respond within 1 second
|
|
});
|
|
|
|
it('should not require authentication', async () => {
|
|
// Test without any authentication headers
|
|
const response = await request(app)
|
|
.get('/health');
|
|
|
|
expect(response.status).to.equal(200);
|
|
});
|
|
});
|
|
|
|
describe('GET /health/detailed', () => {
|
|
it('should return detailed health information', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/detailed')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.status).to.equal('ok');
|
|
expect(response.body.checks).to.exist;
|
|
expect(response.body.checks.database).to.exist;
|
|
expect(response.body.checks.memory).to.exist;
|
|
});
|
|
|
|
it('should require authentication for detailed health', async () => {
|
|
const response = await request(app)
|
|
.get('/health/detailed');
|
|
|
|
expect(response.status).to.equal(401);
|
|
});
|
|
|
|
it('should check database connectivity', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/detailed')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.checks.database.status).to.equal('healthy');
|
|
expect(response.body.checks.database.responseTime).to.be.a('number');
|
|
});
|
|
|
|
it('should include memory usage information', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/detailed')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.checks.memory.status).to.exist;
|
|
expect(response.body.checks.memory.usage).to.be.a('number');
|
|
expect(response.body.checks.memory.total).to.be.a('number');
|
|
});
|
|
|
|
it('should require admin role for detailed health', async () => {
|
|
const tenant = await createTestTenant();
|
|
const user = await createTestUser({ tenant_id: tenant.id, role: 'user' });
|
|
const token = generateTestToken(user, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/detailed')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(403);
|
|
});
|
|
});
|
|
|
|
describe('GET /health/devices', () => {
|
|
it('should return device health summary', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
// Create test devices with different statuses
|
|
const onlineDevice = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
const offlineDevice = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
// Create recent heartbeat for online device
|
|
await models.Heartbeat.create({
|
|
device_id: onlineDevice.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: new Date(),
|
|
status: 'online',
|
|
cpu_usage: 25.5,
|
|
memory_usage: 60.2,
|
|
disk_usage: 45.0
|
|
});
|
|
|
|
// Create old heartbeat for offline device
|
|
await models.Heartbeat.create({
|
|
device_id: offlineDevice.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: new Date(Date.now() - 3600000), // 1 hour ago
|
|
status: 'offline'
|
|
});
|
|
|
|
const response = await request(app)
|
|
.get('/health/devices')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.summary).to.exist;
|
|
expect(response.body.summary.total_devices).to.be.a('number');
|
|
expect(response.body.summary.online_devices).to.be.a('number');
|
|
expect(response.body.summary.offline_devices).to.be.a('number');
|
|
});
|
|
|
|
it('should only show devices for user tenant', async () => {
|
|
const tenant1 = await createTestTenant();
|
|
const tenant2 = await createTestTenant();
|
|
|
|
const admin1 = await createTestUser({ tenant_id: tenant1.id, role: 'admin' });
|
|
const admin2 = await createTestUser({ tenant_id: tenant2.id, role: 'admin' });
|
|
|
|
await createTestDevice({ tenant_id: tenant1.id });
|
|
await createTestDevice({ tenant_id: tenant1.id });
|
|
await createTestDevice({ tenant_id: tenant2.id });
|
|
|
|
const token1 = generateTestToken(admin1, tenant1);
|
|
const response = await request(app)
|
|
.get('/health/devices')
|
|
.set('Authorization', `Bearer ${token1}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.summary.total_devices).to.equal(2); // Only tenant1 devices
|
|
});
|
|
|
|
it('should include device status details', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
await models.Heartbeat.create({
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: new Date(),
|
|
status: 'online',
|
|
cpu_usage: 15.5,
|
|
memory_usage: 40.2,
|
|
disk_usage: 25.0
|
|
});
|
|
|
|
const response = await request(app)
|
|
.get('/health/devices')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.devices).to.be.an('array');
|
|
|
|
const deviceStatus = response.body.devices.find(d => d.id === String(device.id));
|
|
expect(deviceStatus).to.exist;
|
|
expect(deviceStatus.status).to.equal('online');
|
|
expect(deviceStatus.metrics).to.exist;
|
|
expect(deviceStatus.metrics.cpu_usage).to.equal(15.5);
|
|
});
|
|
|
|
it('should calculate device uptime', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const device = await createTestDevice({ tenant_id: tenant.id });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
// Create multiple heartbeats over time
|
|
const now = new Date();
|
|
const oneHourAgo = new Date(now.getTime() - 3600000);
|
|
const twoHoursAgo = new Date(now.getTime() - 7200000);
|
|
|
|
await models.Heartbeat.bulkCreate([
|
|
{
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: twoHoursAgo,
|
|
status: 'online'
|
|
},
|
|
{
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: oneHourAgo,
|
|
status: 'online'
|
|
},
|
|
{
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: now,
|
|
status: 'online'
|
|
}
|
|
]);
|
|
|
|
const response = await request(app)
|
|
.get('/health/devices')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
const deviceStatus = response.body.devices.find(d => d.id === String(device.id));
|
|
expect(deviceStatus.uptime).to.be.a('number');
|
|
});
|
|
});
|
|
|
|
describe('POST /health/devices/:id/heartbeat', () => {
|
|
it('should accept heartbeat from approved device', async () => {
|
|
const tenant = await createTestTenant();
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
const heartbeatData = {
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online',
|
|
cpu_usage: 25.5,
|
|
memory_usage: 60.2,
|
|
disk_usage: 45.0
|
|
};
|
|
|
|
const response = await request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send(heartbeatData);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.success).to.be.true;
|
|
|
|
// Verify heartbeat was saved
|
|
const savedHeartbeat = await models.Heartbeat.findOne({
|
|
where: { device_id: device.id },
|
|
order: [['id', 'DESC']]
|
|
});
|
|
|
|
expect(savedHeartbeat).to.exist;
|
|
expect(savedHeartbeat.status).to.equal('online');
|
|
expect(savedHeartbeat.cpu_usage).to.equal(25.5);
|
|
});
|
|
|
|
it('should reject heartbeat from unapproved device', async () => {
|
|
const tenant = await createTestTenant();
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: false
|
|
});
|
|
|
|
const heartbeatData = {
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online'
|
|
};
|
|
|
|
const response = await request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send(heartbeatData);
|
|
|
|
expect(response.status).to.equal(403);
|
|
expect(response.body.approval_required).to.be.true;
|
|
});
|
|
|
|
it('should reject heartbeat from non-existent device', async () => {
|
|
const heartbeatData = {
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online'
|
|
};
|
|
|
|
const response = await request(app)
|
|
.post('/health/devices/999999/heartbeat')
|
|
.send(heartbeatData);
|
|
|
|
expect(response.status).to.equal(404);
|
|
});
|
|
|
|
it('should validate heartbeat data format', async () => {
|
|
const tenant = await createTestTenant();
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
const invalidPayloads = [
|
|
{}, // Missing required fields
|
|
{ status: 'invalid_status' }, // Invalid status
|
|
{ timestamp: 'invalid_date', status: 'online' }, // Invalid timestamp
|
|
{
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online',
|
|
cpu_usage: 150 // Invalid percentage (>100)
|
|
},
|
|
{
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online',
|
|
invalid_field: 'test' // Invalid field
|
|
}
|
|
];
|
|
|
|
for (const payload of invalidPayloads) {
|
|
const response = await request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send(payload);
|
|
|
|
expect(response.status).to.be.oneOf([400, 422]);
|
|
}
|
|
});
|
|
|
|
it('should handle device status changes', async () => {
|
|
const tenant = await createTestTenant();
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
// Send online heartbeat
|
|
await request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send({
|
|
timestamp: new Date().toISOString(),
|
|
status: 'online',
|
|
cpu_usage: 25.5
|
|
});
|
|
|
|
// Send offline heartbeat
|
|
const offlineResponse = await request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send({
|
|
timestamp: new Date().toISOString(),
|
|
status: 'offline'
|
|
});
|
|
|
|
expect(offlineResponse.status).to.equal(200);
|
|
|
|
// Verify status change was recorded
|
|
const heartbeats = await models.Heartbeat.findAll({
|
|
where: { device_id: device.id },
|
|
order: [['timestamp', 'ASC']]
|
|
});
|
|
|
|
expect(heartbeats).to.have.length(2);
|
|
expect(heartbeats[0].status).to.equal('online');
|
|
expect(heartbeats[1].status).to.equal('offline');
|
|
});
|
|
|
|
it('should handle high-frequency heartbeats efficiently', async () => {
|
|
const tenant = await createTestTenant();
|
|
const device = await createTestDevice({
|
|
tenant_id: tenant.id,
|
|
is_approved: true
|
|
});
|
|
|
|
const heartbeatPromises = [];
|
|
const startTime = Date.now();
|
|
|
|
// Send 10 heartbeats rapidly
|
|
for (let i = 0; i < 10; i++) {
|
|
const promise = request(app)
|
|
.post(`/health/devices/${device.id}/heartbeat`)
|
|
.send({
|
|
timestamp: new Date(startTime + i * 1000).toISOString(),
|
|
status: 'online',
|
|
cpu_usage: 20 + i,
|
|
sequence: i
|
|
});
|
|
|
|
heartbeatPromises.push(promise);
|
|
}
|
|
|
|
const responses = await Promise.all(heartbeatPromises);
|
|
|
|
// All should succeed
|
|
responses.forEach(response => {
|
|
expect(response.status).to.equal(200);
|
|
});
|
|
|
|
// Verify all heartbeats were saved
|
|
const savedHeartbeats = await models.Heartbeat.findAll({
|
|
where: { device_id: device.id }
|
|
});
|
|
|
|
expect(savedHeartbeats).to.have.length(10);
|
|
});
|
|
});
|
|
|
|
describe('GET /health/metrics', () => {
|
|
it('should return system metrics for admin', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/metrics')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.system).to.exist;
|
|
expect(response.body.system.memory).to.exist;
|
|
expect(response.body.system.cpu).to.exist;
|
|
expect(response.body.database).to.exist;
|
|
});
|
|
|
|
it('should require admin role for metrics', async () => {
|
|
const tenant = await createTestTenant();
|
|
const user = await createTestUser({ tenant_id: tenant.id, role: 'user' });
|
|
const token = generateTestToken(user, tenant);
|
|
|
|
const response = await request(app)
|
|
.get('/health/metrics')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(403);
|
|
});
|
|
|
|
it('should include database performance metrics', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
// Generate some database activity
|
|
const device = await createTestDevice({ tenant_id: tenant.id });
|
|
await models.DroneDetection.create({
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
geo_lat: 59.3293,
|
|
geo_lon: 18.0686,
|
|
device_timestamp: new Date(),
|
|
drone_type: 2
|
|
});
|
|
|
|
const response = await request(app)
|
|
.get('/health/metrics')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.database.connection_pool).to.exist;
|
|
expect(response.body.statistics).to.exist;
|
|
expect(response.body.statistics.total_devices).to.be.a('number');
|
|
expect(response.body.statistics.total_detections).to.be.a('number');
|
|
});
|
|
});
|
|
|
|
describe('Health Check Edge Cases', () => {
|
|
it('should handle database connection failures gracefully', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
// Mock database failure
|
|
const originalAuthenticate = sequelize.authenticate;
|
|
sequelize.authenticate = sinon.stub().rejects(new Error('Database connection failed'));
|
|
|
|
const response = await request(app)
|
|
.get('/health/detailed')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200); // Should still respond
|
|
expect(response.body.checks.database.status).to.equal('unhealthy');
|
|
|
|
// Restore original method
|
|
sequelize.authenticate = originalAuthenticate;
|
|
});
|
|
|
|
it('should detect when devices are not reporting', async () => {
|
|
const tenant = await createTestTenant();
|
|
const admin = await createTestUser({ tenant_id: tenant.id, role: 'admin' });
|
|
const device = await createTestDevice({ tenant_id: tenant.id });
|
|
const token = generateTestToken(admin, tenant);
|
|
|
|
// Create old heartbeat (device went silent)
|
|
await models.Heartbeat.create({
|
|
device_id: device.id,
|
|
tenant_id: tenant.id,
|
|
timestamp: new Date(Date.now() - 7200000), // 2 hours ago
|
|
status: 'online'
|
|
});
|
|
|
|
const response = await request(app)
|
|
.get('/health/devices')
|
|
.set('Authorization', `Bearer ${token}`);
|
|
|
|
expect(response.status).to.equal(200);
|
|
const deviceStatus = response.body.devices.find(d => d.id === String(device.id));
|
|
expect(deviceStatus.status).to.be.oneOf(['offline', 'stale', 'unknown']);
|
|
});
|
|
|
|
it('should handle concurrent health checks efficiently', async () => {
|
|
const healthPromises = [];
|
|
|
|
for (let i = 0; i < 5; i++) {
|
|
const promise = request(app).get('/health');
|
|
healthPromises.push(promise);
|
|
}
|
|
|
|
const responses = await Promise.all(healthPromises);
|
|
|
|
responses.forEach(response => {
|
|
expect(response.status).to.equal(200);
|
|
expect(response.body.status).to.equal('ok');
|
|
});
|
|
});
|
|
});
|
|
});
|