task_plan/tests/basic_test.cpp

/**
 * @file basic_test.cpp
 * @brief ETMS 核心功能单元测试（使用标准库 assert，无外部依赖）
 */

#include "app.hpp"

#include <cassert>
#include <iostream>
#include <string>

/**
 * @brief 打印测试结果
 * @param testName 测试名称
 * @param passed   是否通过
 */
static void testResult(const char* testName, bool passed)
{
    std::cout << "  " << (passed ? "[PASS]" : "[FAIL]") << " " << testName << "\n";
}

/**
 * @brief 测试 EventManager 事件接收与校验
 */
static void testEventReceive()
{
    etms::EventManager mgr;

    // 合法事件应返回 ACK
    std::string validJson = R"({"eventId":"E1","eventType":"侦察","timestamp":1000})";
    assert(mgr.receiveEvent(validJson) == true);
    assert(mgr.eventCount() == 1);

    // 缺少关键字段应返回 NACK
    std::string invalidJson = R"({"eventType":"侦察"})";
    assert(mgr.receiveEvent(invalidJson) == false);
    assert(mgr.eventCount() == 1); // 数量不变

    testResult("EventReceive", true);
}

/**
 * @brief 测试事件状态流转
 */
static void testEventStatusFlow()
{
    etms::EventManager mgr;

    std::string json = R"({"eventId":"E2","eventType":"通信","timestamp":2000})";
    mgr.receiveEvent(json);

    // Received → Processed
    assert(mgr.processEvent("E2") == true);
    // 重复处理应失败
    assert(mgr.processEvent("E2") == false);

    // Processed → PendingTask
    assert(mgr.markPendingTask("E2") == true);
    // 重复标记应失败
    assert(mgr.markPendingTask("E2") == false);

    // 查询待处理事件
    auto pending = mgr.getPendingEvents();
    assert(pending.size() == 1);
    assert(pending[0].eventId == "E2");

    // 拒绝操作（在 Rejected 状态测试）
    etms::EventManager mgr2;
    mgr2.receiveEvent(json);
    assert(mgr2.rejectEvent("E2") == true);
    auto ev = mgr2.getEvent("E2");
    assert(static_cast<int>(ev.status) == static_cast<int>(etms::EventStatus::Rejected));

    testResult("EventStatusFlow", true);
}

/**
 * @brief 测试 TaskGenerator 模板管理
 */
static void testTemplateManagement()
{
    etms::TaskGenerator gen;

    // 加载合法模板
    std::string tmplJson = R"({"id":"T1","name":"侦察模板","type":"侦察","version":"1.0"})";
    assert(gen.loadTemplate(tmplJson) == true);

    // 缺少关键字段应失败
    std::string badJson = R"({"name":"无ID模板"})";
    assert(gen.loadTemplate(badJson) == false);

    // 查询模板
    auto tmpl = gen.getTemplate("T1");
    assert(tmpl.id == "T1");
    assert(tmpl.name == "侦察模板");

    // 搜索
    auto results = gen.searchTemplates("侦察");
    assert(results.size() == 1);

    results = gen.searchTemplates("不存在");
    assert(results.empty());

    testResult("TemplateManagement", true);
}

/**
 * @brief 测试知识库版本管理
 */
static void testKBVersionManagement()
{
    etms::TaskGenerator gen;

    etms::KBVersion kb1;
    kb1.id = "KB-V1";
    kb1.status = etms::KBVersionStatus::Enabled;
    gen.addKBVersion(kb1);

    etms::KBVersion kb2;
    kb2.id = "KB-V2";
    kb2.status = etms::KBVersionStatus::Disabled; // 禁用
    gen.addKBVersion(kb2);

    // 可用版本应只返回 Enabled
    auto avail = gen.getAvailableKBVersions();
    assert(avail.size() == 1);
    assert(avail[0].id == "KB-V1");

    // 选择版本
    assert(gen.selectKBVersion("KB-V1") == true);
    assert(gen.getLockedKBVersion() == "KB-V1");

    // 选择禁用版本应失败
    assert(gen.selectKBVersion("KB-V2") == false);
    assert(gen.getLockedKBVersion() == "KB-V1"); // 不变

    testResult("KBVersionManagement", true);
}

/**
 * @brief 测试任务请求组装
 */
static void testTaskRequestBuilding()
{
    etms::TaskGenerator gen;

    // 准备好模板和版本
    std::string tmplJson = R"({"id":"T1","name":"测试模板","type":"测试","version":"1.0"})";
    gen.loadTemplate(tmplJson);

    etms::KBVersion kb;
    kb.id = "KB-V1";
    kb.status = etms::KBVersionStatus::Enabled;
    gen.addKBVersion(kb);
    gen.selectKBVersion("KB-V1");

    // 手动模式映射
    gen.setWorkMode(etms::WorkMode::Manual);
    assert(gen.mapEventToTemplate("EVT-001", "T1") == true);

    // 构建请求
    etms::TaskRequest req = gen.buildTaskRequest("EVT-001");
    assert(req.requestId.find("REQ_EVT-001") == 0);
    assert(req.eventRef == "EVT-001");
    assert(req.templateId == "T1");
    assert(req.kbVersionId == "KB-V1");
    assert(req.workMode == "manual");

    // 未映射的事件应返回默认请求
    etms::TaskRequest emptyReq = gen.buildTaskRequest("EVT-999");
    assert(emptyReq.requestId.empty());

    testResult("TaskRequestBuilding", true);
}

/**
 * @brief 主测试入口
 * @return int 失败返回 1，全部通过返回 0
 */
int main()
{
    std::cout << "══════════════════════════════════════════════════════\n";
    std::cout << "  ETMS Unit Tests (std::assert)\n";
    std::cout << "══════════════════════════════════════════════════════\n\n";

    testEventReceive();
    testEventStatusFlow();
    testTemplateManagement();
    testKBVersionManagement();
    testTaskRequestBuilding();

    std::cout << "\n══════════════════════════════════════════════════════\n";
    std::cout << "  所有测试通过 ✓\n";
    std::cout << "══════════════════════════════════════════════════════\n";

    return 0;
}