test_runtime.js

/**
 * 运行时接口验证测试
 * 启动服务后验证 N1-N4 修复点的运行时行为
 */
const http = require('http');

const BASE = 'http://localhost:3006';
let passed = 0;
let failed = 0;

function req(method, path, body, headers = {}) {
  return new Promise((resolve, reject) => {
    const data = body ? JSON.stringify(body) : null;
    const opts = {
      hostname: 'localhost',
      port: 3006,
      path,
      method,
      headers: {
        'Content-Type': 'application/json',
        ...headers
      }
    };
    if (data) opts.headers['Content-Length'] = Buffer.byteLength(data);
    const r = http.request(opts, (res) => {
      let buf = '';
      res.on('data', c => buf += c);
      res.on('end', () => {
        try {
          resolve({ status: res.statusCode, body: JSON.parse(buf), raw: buf });
        } catch (e) {
          resolve({ status: res.statusCode, body: null, raw: buf });
        }
      });
    });
    r.on('error', reject);
    r.setTimeout(15000, () => { r.destroy(); reject(new Error('timeout')); });
    if (data) r.write(data);
    r.end();
  });
}

async function test(name, fn) {
  try {
    await fn();
    console.log(`  ✅ ${name}`);
    passed++;
  } catch (e) {
    console.error(`  ❌ ${name}: ${e.message}`);
    failed++;
  }
}

function assert(cond, msg) {
  if (!cond) throw new Error(msg);
}

(async () => {
  console.log('=== 运行时接口验证测试 ===\n');

  // ===== 0. 健康检查 =====
  console.log('0. 健康检查');
  await test('GET /api/health 返回200且success=true', async () => {
    const r = await req('GET', '/api/health');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body && r.body.success === true, '应返回success=true');
    assert(r.body.version, '应包含version字段');
    console.log(`     版本: ${r.body.version}, 在线: ${r.body.success}`);
  });

  // ===== N1: db.js saveSync 同步保存 =====
  // 通过报工流程间接验证数据库写入可靠性（不直接调用saveSync，但验证DB读写正常）
  console.log('\nN1: 数据库读写验证（saveSync 间接验证）');
  await test('GET /api/work-report/dsched 数据库读取正常', async () => {
    const r = await req('GET', '/api/work-report/dsched');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body && r.body.success === true, '应返回success=true');
    assert(r.body.date, '应返回date字段');
    console.log(`     日期: ${r.body.date}, 记录数: ${r.body.data?.length || 0}`);
  });

  // ===== N2: workReport 报工接口（旧方式参数校验） =====
  console.log('\nN2: workReport 报工接口验证');
  await test('POST /api/work-report 无参返回400验证错误', async () => {
    const r = await req('POST', '/api/work-report', {});
    assert(r.status === 400, `无参应返回400，实际${r.status}`);
    assert(r.body && r.body.success === false, '应返回success=false');
    assert(r.body.error && r.body.error.code === 'VALIDATION_ERROR', '应返回VALIDATION_ERROR');
  });

  await test('POST /api/work-report 已完成记录拒绝报工', async () => {
    // 先获取当天记录，找一条已完成的
    const list = await req('GET', '/api/work-report/dsched');
    const completed = list.body.data?.find(r => r.status === '已完成');
    if (!completed) {
      console.log('     (当天无已完成记录，跳过此项验证)');
      return;
    }
    const r = await req('POST', '/api/work-report', {
      dschedRowId: completed.rowid,
      completedQty: 999
    });
    assert(r.status === 400, `已完成记录应返回400，实际${r.status}`);
    assert(r.body.error?.code === 'ALREADY_COMPLETED', '应返回ALREADY_COMPLETED');
  });

  // ===== N3: settings /test 接口鉴权 =====
  console.log('\nN3: settings /test 接口鉴权验证');
  await test('GET /api/settings 可访问（脱敏）', async () => {
    const r = await req('GET', '/api/settings');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
    // appKey应被脱敏
    if (r.body.data?.appKey) {
      assert(r.body.data.appKey.includes('****'), 'appKey应被脱敏');
    }
  });

  await test('POST /api/settings/test 接口存在（未配置Token时跳过鉴权）', async () => {
    // 未配置 ADMIN_TOKEN 时，requireAuth 应跳过鉴权直接执行
    // 此处仅验证接口可达且不返回401
    const r = await req('POST', '/api/settings/test', { appKey: '', sign: '' });
    assert(r.status !== 401, `未配置Token时不应返回401，实际${r.status}`);
    // 接口应返回success=false（因为没传凭证）
    if (r.body) {
      console.log(`     响应: success=${r.body.success}, message=${r.body.message || ''}`);
    }
  });

  // ===== N4: dashboard /capacity 接口性能优化 =====
  console.log('\nN4: dashboard /capacity 接口验证');
  await test('GET /api/dashboard/capacity?type=line 返回正常', async () => {
    const r = await req('GET', '/api/dashboard/capacity?type=line');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body && r.body.success === true, '应返回success=true');
    assert(Array.isArray(r.body.data?.datasets), '应返回datasets数组');
    assert(Array.isArray(r.body.data?.dates), '应返回dates数组');
    console.log(`     数据集数: ${r.body.data.datasets.length}, 日期数: ${r.body.data.dates.length}`);
  });

  await test('GET /api/dashboard/capacity?type=line&id=xxx 按产线过滤', async () => {
    // 先获取产线列表
    const filters = await req('GET', '/api/dashboard/filters');
    const firstLine = filters.body?.data?.lines?.[0];
    if (!firstLine) {
      console.log('     (无产线数据，跳过此项验证)');
      return;
    }
    const r = await req('GET', `/api/dashboard/capacity?type=line&id=${firstLine.id}`);
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
    assert(r.body.data.filterId === firstLine.id, 'filterId应等于传入的id');
    console.log(`     过滤产线: ${firstLine.name}, 数据集数: ${r.body.data.datasets.length}`);
  });

  await test('GET /api/dashboard/capacity?type=process 返回正常', async () => {
    const r = await req('GET', '/api/dashboard/capacity?type=process');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
    console.log(`     数据集数: ${r.body.data.datasets.length}`);
  });

  // ===== 其他接口冒烟测试 =====
  console.log('\n其他接口冒烟测试');
  await test('GET /api/dashboard/delivery 交付看板', async () => {
    const r = await req('GET', '/api/dashboard/delivery');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
  });

  await test('GET /api/dashboard/gantt 甘特图', async () => {
    const r = await req('GET', '/api/dashboard/gantt');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
  });

  await test('GET /api/dashboard/daily-line 产线日清', async () => {
    const r = await req('GET', '/api/dashboard/daily-line');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
  });

  await test('GET /api/schedule 历史任务列表', async () => {
    const r = await req('GET', '/api/schedule');
    assert(r.status === 200, `状态码应为200，实际${r.status}`);
    assert(r.body.success === true, '应返回success=true');
    console.log(`     历史任务数: ${r.body.data?.length || 0}`);
  });

  // ===== 结果汇总 =====
  console.log('\n=== 测试结果 ===');
  console.log(`通过: ${passed}  失败: ${failed}  总计: ${passed + failed}`);

  if (failed > 0) {
    console.error('\n❌ 有测试失败，请检查');
    process.exit(1);
  } else {
    console.log('\n✅ 全部测试通过');
    process.exit(0);
  }
})().catch(e => {
  console.error('测试执行异常:', e);
  process.exit(1);
});