380 lines
11 KiB
C++
380 lines
11 KiB
C++
#include <gtest/gtest.h>
|
||
#include <gmock/gmock.h>
|
||
#include "app.hpp"
|
||
#include <string>
|
||
#include <chrono>
|
||
|
||
using namespace testing;
|
||
|
||
// ============================================================================
|
||
// Test Fixture for CmsEngine
|
||
// ============================================================================
|
||
class CmsEngineTest : public ::testing::Test {
|
||
protected:
|
||
void SetUp() override {
|
||
engine = std::make_unique<CmsEngine>();
|
||
}
|
||
|
||
void TearDown() override {
|
||
engine.reset();
|
||
}
|
||
|
||
std::unique_ptr<CmsEngine> engine;
|
||
};
|
||
|
||
// ============================================================================
|
||
// Tests for CmsEngine Constructor
|
||
// ============================================================================
|
||
|
||
/**
|
||
* @brief 测试构造函数初始化系统状态上下文
|
||
*
|
||
* 验证构造函数正确初始化系统状态上下文，包括模式、一致性标记、切换时间和快照。
|
||
*/
|
||
TEST_F(CmsEngineTest, testConstructorInitializesSystemContext) {
|
||
const auto& context = engine->getSystemContext();
|
||
|
||
EXPECT_EQ(context.currentMode, RunMode::Idle);
|
||
EXPECT_EQ(context.consistencyMark, 0);
|
||
|
||
auto now = std::chrono::system_clock::now();
|
||
auto diff = std::chrono::duration_cast<std::chrono::seconds>(now - context.switchTime).count();
|
||
EXPECT_GE(diff, 0);
|
||
EXPECT_LT(diff, 5);
|
||
|
||
EXPECT_THAT(context.contextSnapshot, HasSubstr("\"mode\":\"Idle\""));
|
||
EXPECT_THAT(context.contextSnapshot, HasSubstr("\"version\":\"1.0.0\""));
|
||
}
|
||
|
||
/**
|
||
* @brief 测试构造函数初始化空容器
|
||
*
|
||
* 验证构造函数正确初始化所有容器为空。
|
||
*/
|
||
TEST_F(CmsEngineTest, testConstructorInitializesEmptyContainers) {
|
||
EXPECT_EQ(engine->getAllPlans().size(), 0);
|
||
|
||
std::string summary = engine->getSummary();
|
||
EXPECT_THAT(summary, HasSubstr("Events : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Plans : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Templates : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Monitor Nodes : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Active Sessions : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Notifications : 0"));
|
||
EXPECT_THAT(summary, HasSubstr("Mode : Idle"));
|
||
}
|
||
|
||
// ============================================================================
|
||
// Tests for ingestEvent
|
||
// ============================================================================
|
||
|
||
/**
|
||
* @brief 测试正常事件接入
|
||
*
|
||
* 验证具有有效 ID 和合法优先级的事件能够成功接入。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventValidEvent) {
|
||
EventRecord event;
|
||
event.id = "EVT-001";
|
||
event.priority = 100;
|
||
event.status = EventStatus::Pending;
|
||
|
||
bool result = engine->ingestEvent(event);
|
||
EXPECT_TRUE(result);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("EVT-001");
|
||
ASSERT_NE(storedEvent, nullptr);
|
||
EXPECT_EQ(storedEvent->id, "EVT-001");
|
||
EXPECT_EQ(storedEvent->priority, 100);
|
||
EXPECT_EQ(storedEvent->status, EventStatus::Pending);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入优先级为 0 的事件
|
||
*
|
||
* 验证优先级为 0（最小值）的事件能够成功接入。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventMinPriority) {
|
||
EventRecord event;
|
||
event.id = "EVT-002";
|
||
event.priority = 0;
|
||
event.status = EventStatus::Pending;
|
||
|
||
bool result = engine->ingestEvent(event);
|
||
EXPECT_TRUE(result);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("EVT-002");
|
||
ASSERT_NE(storedEvent, nullptr);
|
||
EXPECT_EQ(storedEvent->priority, 0);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入优先级为 255 的事件
|
||
*
|
||
* 验证优先级为 255（最大值）的事件能够成功接入。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventMaxPriority) {
|
||
EventRecord event;
|
||
event.id = "EVT-003";
|
||
event.priority = 255;
|
||
event.status = EventStatus::Pending;
|
||
|
||
bool result = engine->ingestEvent(event);
|
||
EXPECT_TRUE(result);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("EVT-003");
|
||
ASSERT_NE(storedEvent, nullptr);
|
||
EXPECT_EQ(storedEvent->priority, 255);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入空 ID 事件
|
||
*
|
||
* 验证 ID 为空的事件接入失败，返回 false。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventEmptyId) {
|
||
EventRecord event;
|
||
event.id = "";
|
||
event.priority = 100;
|
||
event.status = EventStatus::Pending;
|
||
|
||
bool result = engine->ingestEvent(event);
|
||
EXPECT_FALSE(result);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("");
|
||
EXPECT_EQ(storedEvent, nullptr);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入优先级超限事件
|
||
*
|
||
* 验证优先级大于 255 的事件接入失败，返回 false。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventPriorityExceedsMax) {
|
||
EventRecord event;
|
||
event.id = "EVT-004";
|
||
event.priority = 256;
|
||
event.status = EventStatus::Pending;
|
||
|
||
bool result = engine->ingestEvent(event);
|
||
EXPECT_FALSE(result);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("EVT-004");
|
||
EXPECT_EQ(storedEvent, nullptr);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入多个事件
|
||
*
|
||
* 验证多个事件能够依次成功接入，且事件列表正确增长。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventMultipleEvents) {
|
||
EventRecord event1;
|
||
event1.id = "EVT-005";
|
||
event1.priority = 50;
|
||
event1.status = EventStatus::Pending;
|
||
|
||
EventRecord event2;
|
||
event2.id = "EVT-006";
|
||
event2.priority = 150;
|
||
event2.status = EventStatus::Pending;
|
||
|
||
EXPECT_TRUE(engine->ingestEvent(event1));
|
||
EXPECT_TRUE(engine->ingestEvent(event2));
|
||
|
||
const EventRecord* storedEvent1 = engine->findEventById("EVT-005");
|
||
ASSERT_NE(storedEvent1, nullptr);
|
||
EXPECT_EQ(storedEvent1->priority, 50);
|
||
|
||
const EventRecord* storedEvent2 = engine->findEventById("EVT-006");
|
||
ASSERT_NE(storedEvent2, nullptr);
|
||
EXPECT_EQ(storedEvent2->priority, 150);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试接入事件后处理待处理事件
|
||
*
|
||
* 验证接入 Pending 状态的事件后，processPendingEvents 能正确处理。
|
||
*/
|
||
TEST_F(CmsEngineTest, testIngestEventAndProcessPending) {
|
||
EventRecord event;
|
||
event.id = "EVT-007";
|
||
event.priority = 100;
|
||
event.status = EventStatus::Pending;
|
||
|
||
EXPECT_TRUE(engine->ingestEvent(event));
|
||
|
||
size_t processedCount = engine->processPendingEvents();
|
||
EXPECT_EQ(processedCount, 1);
|
||
|
||
const EventRecord* storedEvent = engine->findEventById("EVT-007");
|
||
ASSERT_NE(storedEvent, nullptr);
|
||
EXPECT_EQ(storedEvent->status, EventStatus::Generated);
|
||
|
||
// 通过 getAllPlans 获取方案列表，验证自动生成的方案
|
||
const auto& plans = engine->getAllPlans();
|
||
ASSERT_EQ(plans.size(), 1);
|
||
EXPECT_EQ(plans[0].relatedEventId, "EVT-007");
|
||
EXPECT_EQ(plans[0].name, "AutoPlan-EVT-007");
|
||
}
|
||
|
||
// ============================================================================
|
||
// Tests for findPlanById
|
||
// ============================================================================
|
||
|
||
/**
|
||
* @brief 测试查找存在的方案
|
||
*
|
||
* 验证能够通过 ID 查找到已创建的任务方案。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdExistingPlan) {
|
||
TaskPlan plan;
|
||
plan.name = "TestPlan";
|
||
plan.type = PlanType::Centralized;
|
||
plan.status = PlanStatus::Drafting;
|
||
plan.resourceQuota = 0.8;
|
||
plan.constraints = "测试约束";
|
||
|
||
EXPECT_TRUE(engine->createTaskPlan(plan));
|
||
|
||
std::string planId = plan.id;
|
||
EXPECT_FALSE(planId.empty());
|
||
|
||
const TaskPlan* foundPlan = engine->findPlanById(planId);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->id, planId);
|
||
EXPECT_EQ(foundPlan->name, "TestPlan");
|
||
EXPECT_EQ(foundPlan->type, PlanType::Centralized);
|
||
EXPECT_EQ(foundPlan->status, PlanStatus::Drafting);
|
||
EXPECT_DOUBLE_EQ(foundPlan->resourceQuota, 0.8);
|
||
EXPECT_EQ(foundPlan->constraints, "测试约束");
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找不存在的方案
|
||
*
|
||
* 验证查找不存在的 ID 时返回 nullptr。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdNonExistentPlan) {
|
||
const TaskPlan* foundPlan = engine->findPlanById("NONEXISTENT");
|
||
EXPECT_EQ(foundPlan, nullptr);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找空 ID 方案
|
||
*
|
||
* 验证查找空字符串 ID 时返回 nullptr。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdEmptyId) {
|
||
const TaskPlan* foundPlan = engine->findPlanById("");
|
||
EXPECT_EQ(foundPlan, nullptr);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找多个方案中的特定方案
|
||
*
|
||
* 验证在多个方案中能够正确查找到指定 ID 的方案。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdAmongMultiplePlans) {
|
||
TaskPlan plan1;
|
||
plan1.name = "PlanAlpha";
|
||
EXPECT_TRUE(engine->createTaskPlan(plan1));
|
||
std::string id1 = plan1.id;
|
||
|
||
TaskPlan plan2;
|
||
plan2.name = "PlanBeta";
|
||
EXPECT_TRUE(engine->createTaskPlan(plan2));
|
||
std::string id2 = plan2.id;
|
||
|
||
TaskPlan plan3;
|
||
plan3.name = "PlanGamma";
|
||
EXPECT_TRUE(engine->createTaskPlan(plan3));
|
||
std::string id3 = plan3.id;
|
||
|
||
EXPECT_NE(id1, id2);
|
||
EXPECT_NE(id2, id3);
|
||
EXPECT_NE(id1, id3);
|
||
|
||
const TaskPlan* foundPlan = engine->findPlanById(id2);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->id, id2);
|
||
EXPECT_EQ(foundPlan->name, "PlanBeta");
|
||
|
||
foundPlan = engine->findPlanById(id1);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->id, id1);
|
||
EXPECT_EQ(foundPlan->name, "PlanAlpha");
|
||
|
||
foundPlan = engine->findPlanById(id3);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->id, id3);
|
||
EXPECT_EQ(foundPlan->name, "PlanGamma");
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找已更新状态的方案
|
||
*
|
||
* 验证方案状态更新后仍能查找到，且状态正确。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdAfterStatusUpdate) {
|
||
TaskPlan plan;
|
||
plan.name = "StatusTestPlan";
|
||
EXPECT_TRUE(engine->createTaskPlan(plan));
|
||
std::string planId = plan.id;
|
||
|
||
EXPECT_TRUE(engine->updatePlanStatus(planId, PlanStatus::Approved));
|
||
|
||
const TaskPlan* foundPlan = engine->findPlanById(planId);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->status, PlanStatus::Approved);
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找通过事件处理生成的方案
|
||
*
|
||
* 验证通过 processPendingEvents 自动生成的方案能够被正确查找。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdGeneratedFromEvent) {
|
||
EventRecord event;
|
||
event.id = "EVT-GEN-001";
|
||
event.priority = 100;
|
||
event.status = EventStatus::Pending;
|
||
EXPECT_TRUE(engine->ingestEvent(event));
|
||
|
||
size_t processedCount = engine->processPendingEvents();
|
||
EXPECT_EQ(processedCount, 1);
|
||
|
||
// 通过 getAllPlans 获取方案列表，验证自动生成的方案
|
||
const auto& plans = engine->getAllPlans();
|
||
ASSERT_EQ(plans.size(), 1);
|
||
std::string planId = plans[0].id;
|
||
EXPECT_FALSE(planId.empty());
|
||
|
||
const TaskPlan* foundPlan = engine->findPlanById(planId);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->relatedEventId, "EVT-GEN-001");
|
||
EXPECT_EQ(foundPlan->name, "AutoPlan-EVT-GEN-001");
|
||
EXPECT_EQ(foundPlan->type, PlanType::Centralized);
|
||
EXPECT_EQ(foundPlan->status, PlanStatus::Drafting);
|
||
EXPECT_DOUBLE_EQ(foundPlan->resourceQuota, 0.5);
|
||
EXPECT_EQ(foundPlan->constraints, "自动生成约束");
|
||
}
|
||
|
||
/**
|
||
* @brief 测试查找方案时的常量正确性
|
||
*
|
||
* 验证 const 版本的 findPlanById 返回的指针指向常量对象。
|
||
*/
|
||
TEST_F(CmsEngineTest, testFindPlanByIdConstCorrectness) {
|
||
TaskPlan plan;
|
||
plan.name = "ConstTestPlan";
|
||
EXPECT_TRUE(engine->createTaskPlan(plan));
|
||
std::string planId = plan.id;
|
||
|
||
const CmsEngine& constEngine = *engine;
|
||
const TaskPlan* foundPlan = constEngine.findPlanById(planId);
|
||
ASSERT_NE(foundPlan, nullptr);
|
||
EXPECT_EQ(foundPlan->id, planId);
|
||
EXPECT_EQ(foundPlan->name, "ConstTestPlan");
|
||
}
|