200 lines
8.1 KiB
JavaScript
200 lines
8.1 KiB
JavaScript
// TDD Test: Verifikasi fix untuk Bug #1 (Devices) dan Bug #2 (Flows)
|
|
// Jalankan: node backend/tests/test_bug_fixes.js
|
|
|
|
const path = require('path');
|
|
require('dotenv').config({ path: path.join(__dirname, '../../.env.local') });
|
|
|
|
const API_KEY = process.env.NETIFY_API_KEY;
|
|
const SITE_UUID = process.env.NETIFY_SITE_UUID;
|
|
const BASE = 'https://informatics.netify.ai/api/v1';
|
|
const axios = require('axios');
|
|
|
|
const headers = {
|
|
'x-api-key': API_KEY,
|
|
'x-net-site': SITE_UUID,
|
|
'Accept': 'application/json'
|
|
};
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
|
|
function assert(condition, message) {
|
|
if (condition) {
|
|
console.log(` ✅ PASS: ${message}`);
|
|
passed++;
|
|
} else {
|
|
console.error(` ❌ FAIL: ${message}`);
|
|
failed++;
|
|
}
|
|
}
|
|
|
|
async function testDevicesBugFix() {
|
|
console.log('\n=== BUG #1: DEVICES - Download/Upload/Type/OS Fix ===');
|
|
|
|
const [dlResp, ulResp, devResp, flowsResp] = await Promise.all([
|
|
axios.get(`${BASE}/data/stats/top/local_ip/download`, { headers, params: { filter_interval: 1440, settings_limit: 500 }, timeout: 15000 }),
|
|
axios.get(`${BASE}/data/stats/top/local_ip/upload`, { headers, params: { filter_interval: 1440, settings_limit: 500 }, timeout: 15000 }),
|
|
axios.get(`${BASE}/intelligence/discovery/devices`, { headers, params: { settings_limit: 500 }, timeout: 15000 }),
|
|
axios.get(`${BASE}/data/flows`, { headers, params: { settings_limit: 500 }, timeout: 15000 }),
|
|
]);
|
|
|
|
const dlData = dlResp.data?.data || [];
|
|
const ulData = ulResp.data?.data || [];
|
|
const devData = devResp.data?.data || [];
|
|
const flowData = flowsResp.data?.data || [];
|
|
|
|
console.log(` Total IPs in download stats: ${dlData.length}`);
|
|
console.log(` Total IPs in upload stats: ${ulData.length}`);
|
|
console.log(` Total discovered devices: ${devData.length}`);
|
|
console.log(` Total flows: ${flowData.length}`);
|
|
|
|
// Build maps
|
|
const dlMap = {};
|
|
for (const r of dlData) {
|
|
if (r.local_ip?.address) dlMap[r.local_ip.address] = r.download;
|
|
}
|
|
const ulMap = {};
|
|
for (const r of ulData) {
|
|
if (r.local_ip?.address) ulMap[r.local_ip.address] = r.upload;
|
|
}
|
|
// Flows fallback map
|
|
const dlFlowMap = {};
|
|
const ulFlowMap = {};
|
|
for (const f of flowData) {
|
|
const ip = f.local_ip?.address;
|
|
if (!ip) continue;
|
|
if (!dlMap[ip]) dlFlowMap[ip] = (dlFlowMap[ip] || 0) + (f.download || 0);
|
|
if (!ulMap[ip]) ulFlowMap[ip] = (ulFlowMap[ip] || 0) + (f.upload || 0);
|
|
}
|
|
|
|
// Test: devices dengan non-zero bandwidth setelah enrichment
|
|
const enriched = devData.map(r => {
|
|
const ip = r.ip?.address;
|
|
const dl = ip ? (dlMap[ip] || dlFlowMap[ip] || 0) : 0;
|
|
const ul = ip ? (ulMap[ip] || ulFlowMap[ip] || 0) : 0;
|
|
const type = r.discovery_type?.label;
|
|
const os = r.discovery_os?.label;
|
|
return { ip, dl, ul, type, os };
|
|
}).sort((a, b) => (b.dl + b.ul) - (a.dl + a.ul));
|
|
|
|
const withBandwidth = enriched.filter(d => d.dl > 0 || d.ul > 0);
|
|
const withType = enriched.filter(d => d.type && d.type !== 'Unknown' && d.type !== 'Unclassified');
|
|
const withOs = enriched.filter(d => d.os && d.os !== 'Unknown' && d.os !== 'Unclassified');
|
|
|
|
assert(enriched.length > 0, `Devices tersedia: ${enriched.length} entries`);
|
|
assert(withBandwidth.length > 0, `Devices dengan bandwidth non-zero: ${withBandwidth.length}/${enriched.length}`);
|
|
assert(withType.length > 0, `Devices dengan type terdeteksi: ${withType.length}/${enriched.length}`);
|
|
assert(withOs.length > 0, `Devices dengan OS terdeteksi: ${withOs.length}/${enriched.length}`);
|
|
|
|
// Print top 5 devices
|
|
console.log('\n Top 5 devices after fix:');
|
|
for (const d of enriched.slice(0, 5)) {
|
|
console.log(` IP=${d.ip}, DL=${(d.dl / 1024 / 1024).toFixed(2)}MB, UL=${(d.ul / 1024 / 1024).toFixed(2)}MB, type=${d.type || '-'}, os=${d.os || '-'}`);
|
|
}
|
|
}
|
|
|
|
async function testFlowsBugFix() {
|
|
console.log('\n=== BUG #2: FLOWS - App/Domain Column Fix ===');
|
|
|
|
const [flowsResp, tslSniResp] = await Promise.all([
|
|
axios.get(`${BASE}/data/flows`, { headers, params: { settings_limit: 50 }, timeout: 15000 }),
|
|
axios.get(`${BASE}/data/stats/top/tls_sni/download`, { headers, params: { filter_interval: 1440, settings_limit: 50 }, timeout: 15000 }),
|
|
]);
|
|
|
|
const flowData = flowsResp.data?.data || [];
|
|
const sniData = tslSniResp.data?.data || [];
|
|
|
|
const PORT_SERVICE_MAP = {
|
|
80: 'HTTP', 443: 'HTTPS / TLS', 8080: 'HTTP Alt', 8443: 'HTTPS Alt',
|
|
53: 'DNS', 5353: 'mDNS', 853: 'DNS-over-TLS',
|
|
22: 'SSH', 23: 'Telnet', 3389: 'RDP', 5900: 'VNC',
|
|
9993: 'ZeroTier VPN', 3478: 'STUN/TURN', 5004: 'RTP Media',
|
|
5060: 'SIP', 5061: 'SIP TLS', 1194: 'OpenVPN', 51820: 'WireGuard',
|
|
500: 'IPSec IKE', 4500: 'IPSec NAT-T', 1723: 'PPTP', 1701: 'L2TP',
|
|
67: 'DHCP', 68: 'DHCP Client', 123: 'NTP', 161: 'SNMP',
|
|
};
|
|
|
|
const sniList = sniData.map(r => r.tls_sni || '').filter(s => s.trim() !== '');
|
|
console.log(` TLS SNI hostnames available: ${sniList.length}`);
|
|
|
|
const enrichedFlows = flowData.map(r => {
|
|
const port = r.remote_port ?? null;
|
|
const portService = port ? (PORT_SERVICE_MAP[port] ?? `Port ${port}`) : null;
|
|
let domain = null;
|
|
let appLabel = portService;
|
|
if ((port === 443 || port === 8443) && sniList.length > 0) {
|
|
domain = sniList[0];
|
|
}
|
|
return { src: r.local_ip?.address, dst: r.remote_ip?.address, port, appLabel, domain };
|
|
});
|
|
|
|
const withAppLabel = enrichedFlows.filter(f => f.appLabel !== null);
|
|
|
|
assert(enrichedFlows.length > 0, `Flows tersedia: ${enrichedFlows.length} entries`);
|
|
assert(withAppLabel.length > 0, `Flows dengan app_label terisi (port-based): ${withAppLabel.length}/${enrichedFlows.length}`);
|
|
|
|
// Count unique app labels
|
|
const labelCounts = {};
|
|
for (const f of enrichedFlows) {
|
|
const k = f.appLabel || 'Unknown';
|
|
labelCounts[k] = (labelCounts[k] || 0) + 1;
|
|
}
|
|
console.log(' App label distribution:', JSON.stringify(labelCounts));
|
|
|
|
// Print sample flows
|
|
console.log('\n Sample flows after fix:');
|
|
for (const f of enrichedFlows.slice(0, 5)) {
|
|
console.log(` ${f.src} -> ${f.dst}:${f.port} | app="${f.appLabel || '-'}" domain="${f.domain || '-'}"`);
|
|
}
|
|
}
|
|
|
|
async function testBackendAPI() {
|
|
console.log('\n=== BACKEND API VERIFICATION ===');
|
|
try {
|
|
const r = await axios.get('http://localhost:3001/api/dashboard/flows?limit=10', { timeout: 5000 });
|
|
const flows = r.data?.data || [];
|
|
assert(r.data?.ok === true, 'Backend /flows endpoint responds OK');
|
|
assert(flows.length > 0, `Flows dari backend: ${flows.length} entries`);
|
|
const withApp = flows.filter(f => f.app_label !== null);
|
|
assert(withApp.length > 0, `Flows dengan app_label dari backend: ${withApp.length}/${flows.length}`);
|
|
console.log(' Sample from backend:');
|
|
for (const f of flows.slice(0, 3)) {
|
|
console.log(` ${f.src_ip} -> ${f.dst_ip}:${f.dst_port} | app="${f.app_label || '-'}" domain="${f.domain || '-'}" dl=${f.bytes_download} ul=${f.bytes_upload}`);
|
|
}
|
|
} catch (e) {
|
|
console.log(` Backend API test skipped: ${e.message}`);
|
|
}
|
|
|
|
try {
|
|
const r = await axios.get('http://localhost:3001/api/dashboard/devices?limit=10', { timeout: 5000 });
|
|
const devs = r.data?.data || [];
|
|
assert(r.data?.ok === true, 'Backend /devices endpoint responds OK');
|
|
assert(devs.length > 0, `Devices dari backend: ${devs.length} entries`);
|
|
const withType = devs.filter(d => d.device_type !== null);
|
|
const withOs = devs.filter(d => d.os_label !== null);
|
|
const withBw = devs.filter(d => d.download > 0 || d.upload > 0);
|
|
assert(withBw.length > 0, `Devices dengan bandwidth non-zero dari backend: ${withBw.length}/${devs.length}`);
|
|
console.log(' Sample devices from backend:');
|
|
for (const d of devs.slice(0, 3)) {
|
|
console.log(` IP=${d.ip_address}, DL=${(d.download / 1024 / 1024).toFixed(2)}MB, type=${d.device_type || '-'}, os=${d.os_label || '-'}`);
|
|
}
|
|
} catch (e) {
|
|
console.log(` Backend /devices test skipped: ${e.message}`);
|
|
}
|
|
}
|
|
|
|
async function run() {
|
|
console.log('=== TDD: Bug Fix Verification Tests ===\n');
|
|
await testDevicesBugFix();
|
|
await testFlowsBugFix();
|
|
await testBackendAPI();
|
|
|
|
console.log(`\n=== RESULT: ${passed} passed, ${failed} failed ===`);
|
|
if (failed > 0) process.exit(1);
|
|
}
|
|
|
|
run().catch(e => {
|
|
console.error('FATAL:', e.message);
|
|
process.exit(1);
|
|
});
|