plan_execute_t1/tests/test_app.cpp

#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <chrono>
#include "app.hpp"

// ============================================================================
// 测试夹具：CmsEngineTest
// ============================================================================
class CmsEngineTest : public ::testing::Test {
protected:
    CmsEngine engine;

    void SetUp() override {
        // 每个测试用例开始前重置引擎状态
    }

    void TearDown() override {
        // 每个测试用例结束后清理
    }

    // 辅助函数：创建一个有效的事件记录
    EventRecord createValidEvent(const std::string& id = "EVT-001",
                                  uint32_t priority = 100,
                                  EventStatus status = EventStatus::Pending) {
        EventRecord event;
        event.id = id;
        event.priority = priority;
        event.status = status;
        event.timestamp = std::chrono::system_clock::now();
        event.source = "TestSource";
        event.description = "Test event description";
        return event;
    }
};

// ============================================================================
// ingestEvent 函数测试
// ============================================================================

// 测试用例 1：正常输入测试 - 有效事件接入成功
TEST_F(CmsEngineTest, testIngestEventValidEvent) {
    EventRecord event = createValidEvent();
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
}

// 测试用例 2：边界值测试 - 事件 ID 为空字符串
TEST_F(CmsEngineTest, testIngestEventEmptyId) {
    EventRecord event = createValidEvent("", 100);
    bool result = engine.ingestEvent(event);
    EXPECT_FALSE(result);
}

// 测试用例 3：边界值测试 - 事件优先级为 0（最小值）
TEST_F(CmsEngineTest, testIngestEventPriorityZero) {
    EventRecord event = createValidEvent("EVT-002", 0);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
}

// 测试用例 4：边界值测试 - 事件优先级为 255（最大值）
TEST_F(CmsEngineTest, testIngestEventPriorityMax) {
    EventRecord event = createValidEvent("EVT-003", 255);
    bool result = engine.ingestEvent(event);
    EXPECT_TRUE(result);
}

// 测试用例 5：异常输入测试 - 事件优先级超过 255
TEST_F(CmsEngineTest, testIngestEventPriorityExceedsMax) {
    EventRecord event = createValidEvent("EVT-004", 256);
    bool result = engine.ingestEvent(event);
    EXPECT_FALSE(result);
}

// 测试用例 6：异常输入测试 - 事件优先级为极大值
TEST_F(CmsEngineTest, testIngestEventPriorityVeryHigh) {
    EventRecord event = createValidEvent("EVT-005", 1000);
    bool result = engine.ingestEvent(event);
    EXPECT_FALSE(result);
}

// 测试用例 7：特殊场景测试 - 多次接入相同 ID 的事件
TEST_F(CmsEngineTest, testIngestEventDuplicateId) {
    EventRecord event1 = createValidEvent("EVT-006", 50);
    EventRecord event2 = createValidEvent("EVT-006", 100);
    EXPECT_TRUE(engine.ingestEvent(event1));
    EXPECT_TRUE(engine.ingestEvent(event2));
}

// 测试用例 8：特殊场景测试 - 接入大量事件
TEST_F(CmsEngineTest, testIngestEventMultipleEvents) {
    const size_t eventCount = 100;
    for (size_t i = 0; i < eventCount; ++i) {
        EventRecord event = createValidEvent("EVT-" + std::to_string(i), i % 256);
        EXPECT_TRUE(engine.ingestEvent(event));
    }
}

// ============================================================================
// processPendingEvents 函数测试
// ============================================================================

// 测试用例 9：正常输入测试 - 处理单个待处理事件
TEST_F(CmsEngineTest, testProcessPendingEventsSingleEvent) {
    EventRecord event = createValidEvent("EVT-010", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 1);
}

// 测试用例 10：正常输入测试 - 处理多个待处理事件
TEST_F(CmsEngineTest, testProcessPendingEventsMultipleEvents) {
    for (int i = 0; i < 5; ++i) {
        EventRecord event = createValidEvent("EVT-" + std::to_string(i + 100), 50, EventStatus::Pending);
        engine.ingestEvent(event);
    }
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 5);
}

// 测试用例 11：边界值测试 - 没有待处理事件（事件状态为 Generated）
TEST_F(CmsEngineTest, testProcessPendingEventsNoPendingEvents) {
    EventRecord event = createValidEvent("EVT-200", 100, EventStatus::Generated);
    engine.ingestEvent(event);
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 0);
}

// 测试用例 12：边界值测试 - 事件队列为空
TEST_F(CmsEngineTest, testProcessPendingEventsEmptyQueue) {
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 0);
}

// 测试用例 13：边界值测试 - 混合状态的事件
TEST_F(CmsEngineTest, testProcessPendingEventsMixedStatus) {
    EventRecord pendingEvent1 = createValidEvent("EVT-300", 100, EventStatus::Pending);
    EventRecord pendingEvent2 = createValidEvent("EVT-301", 200, EventStatus::Pending);
    EventRecord generatedEvent = createValidEvent("EVT-302", 150, EventStatus::Generated);
    engine.ingestEvent(pendingEvent1);
    engine.ingestEvent(pendingEvent2);
    engine.ingestEvent(generatedEvent);
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, 2);
}

// 测试用例 14：特殊场景测试 - 处理事件后状态变为 Generated
TEST_F(CmsEngineTest, testProcessPendingEventsStatusChange) {
    EventRecord event = createValidEvent("EVT-400", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    engine.processPendingEvents();
    const EventRecord* foundEvent = engine.findEventById("EVT-400");
    ASSERT_NE(foundEvent, nullptr);
    EXPECT_EQ(foundEvent->status, EventStatus::Generated);
}

// 测试用例 15：特殊场景测试 - 处理事件后生成对应的 TaskPlan
TEST_F(CmsEngineTest, testProcessPendingEventsGeneratesPlan) {
    EventRecord event = createValidEvent("EVT-500", 100, EventStatus::Pending);
    engine.ingestEvent(event);
    engine.processPendingEvents();
    const auto& plans = engine.getAllPlans();
    ASSERT_EQ(plans.size(), 1);
    EXPECT_EQ(plans[0].relatedEventId, "EVT-500");
    EXPECT_EQ(plans[0].name, "AutoPlan-EVT-500");
    EXPECT_EQ(plans[0].type, PlanType::Centralized);
    EXPECT_EQ(plans[0].status, PlanStatus::Drafting);
    EXPECT_EQ(plans[0].resourceQuota, 0.5);
    EXPECT_EQ(plans[0].constraints, "自动生成约束");
}

// 测试用例 16：特殊场景测试 - 多次调用 processPendingEvents
TEST_F(CmsEngineTest, testProcessPendingEventsMultipleCalls) {
    EventRecord event1 = createValidEvent("EVT-600", 100, EventStatus::Pending);
    engine.ingestEvent(event1);
    size_t firstCall = engine.processPendingEvents();
    EXPECT_EQ(firstCall, 1);
    size_t secondCall = engine.processPendingEvents();
    EXPECT_EQ(secondCall, 0);
}

// 测试用例 17：特殊场景测试 - 大量待处理事件
TEST_F(CmsEngineTest, testProcessPendingEventsLargeBatch) {
    const size_t eventCount = 1000;
    for (size_t i = 0; i < eventCount; ++i) {
        EventRecord event = createValidEvent("EVT-" + std::to_string(i + 1000), i % 256, EventStatus::Pending);
        engine.ingestEvent(event);
    }
    size_t processed = engine.processPendingEvents();
    EXPECT_EQ(processed, eventCount);
}