AI 自动生成测试用例
This commit is contained in:
hzy
parent
f3cd8962e6
commit
a8f88ee46d
|
|
@ -0,0 +1,25 @@
|
|||
cmake_minimum_required(VERSION 3.10.0)
|
||||
project(test_ODF)
|
||||
include(FetchContent)
|
||||
if (MSVC)
|
||||
add_compile_options(/utf-8)
|
||||
endif()
|
||||
FetchContent_Declare(
|
||||
googletest
|
||||
URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
|
||||
)
|
||||
# For Windows: Prevent overriding the parent project's compiler/linker settings
|
||||
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
|
||||
FetchContent_MakeAvailable(googletest)
|
||||
set(CMAKE_CXX_STANDARD 14)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include)
|
||||
|
||||
include(CTest)
|
||||
enable_testing()
|
||||
|
||||
add_executable(test_ODF test_odf_manager.cpp ../app/main.py test_odf_service.cpp ../app/services.py)
|
||||
|
||||
target_link_libraries(test_ODF gtest gmock gtest_main)
|
||||
include(GoogleTest)
|
||||
gtest_discover_tests(test_ODF)
|
||||
|
|
@ -0,0 +1,418 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <optional>
|
||||
#include <stdexcept>
|
||||
|
||||
// ==================== 模拟数据结构 ====================
|
||||
|
||||
enum class PortType { SC, LC, FC, ST };
|
||||
|
||||
struct RackCreate {
|
||||
std::string rack_name;
|
||||
std::string location;
|
||||
};
|
||||
|
||||
struct UnitCreate {
|
||||
int unit_number;
|
||||
std::string unit_name;
|
||||
int position;
|
||||
int port_count;
|
||||
PortType port_type;
|
||||
};
|
||||
|
||||
struct ConnectionCreate {
|
||||
std::string port_a_id;
|
||||
std::string port_b_id;
|
||||
double fiber_length;
|
||||
std::string remark;
|
||||
};
|
||||
|
||||
struct RackListResponse {
|
||||
std::string rack_id;
|
||||
std::string rack_name;
|
||||
int unit_count;
|
||||
};
|
||||
|
||||
struct PortResponse {
|
||||
std::string port_id;
|
||||
int port_number;
|
||||
PortType port_type;
|
||||
std::string status;
|
||||
};
|
||||
|
||||
struct UnitResponse {
|
||||
std::string unit_id;
|
||||
int unit_number;
|
||||
std::string unit_name;
|
||||
int position;
|
||||
std::vector<PortResponse> ports;
|
||||
};
|
||||
|
||||
struct RackResponse {
|
||||
std::string rack_id;
|
||||
std::string rack_name;
|
||||
std::string location;
|
||||
std::vector<UnitResponse> units;
|
||||
};
|
||||
|
||||
struct FreePortResponse {
|
||||
std::string port_id;
|
||||
std::string rack_id;
|
||||
int unit_number;
|
||||
int port_number;
|
||||
PortType port_type;
|
||||
};
|
||||
|
||||
struct PortDetail {
|
||||
std::string port_id;
|
||||
int port_number;
|
||||
PortType port_type;
|
||||
std::string status;
|
||||
std::string unit_id;
|
||||
std::string rack_id;
|
||||
};
|
||||
|
||||
struct ConnectionResponse {
|
||||
std::string connection_id;
|
||||
std::string port_a_id;
|
||||
std::string port_b_id;
|
||||
double fiber_length;
|
||||
std::string remark;
|
||||
};
|
||||
|
||||
// ==================== 被测服务类（模拟实现） ====================
|
||||
|
||||
class ODFService {
|
||||
public:
|
||||
virtual ~ODFService() = default;
|
||||
|
||||
virtual std::vector<RackListResponse> list_racks() = 0;
|
||||
virtual std::optional<RackResponse> get_rack(const std::string& rack_id) = 0;
|
||||
virtual RackResponse create_rack(const RackCreate& body) = 0;
|
||||
virtual bool delete_rack(const std::string& rack_id) = 0;
|
||||
virtual std::optional<UnitResponse> create_unit(const std::string& rack_id, const UnitCreate& body) = 0;
|
||||
virtual bool delete_unit(const std::string& unit_id) = 0;
|
||||
virtual std::vector<FreePortResponse> get_free_ports(const std::optional<std::string>& rack_id) = 0;
|
||||
virtual std::optional<PortDetail> get_port_detail(const std::string& port_id) = 0;
|
||||
virtual std::vector<ConnectionResponse> list_connections() = 0;
|
||||
virtual std::optional<ConnectionResponse> create_connection(const ConnectionCreate& body) = 0;
|
||||
virtual bool delete_connection(const std::string& connection_id) = 0;
|
||||
virtual std::optional<std::string> get_port_path(const std::string& port_id) = 0;
|
||||
virtual std::string health_check() = 0;
|
||||
};
|
||||
|
||||
// 模拟实现（用于测试基类）
|
||||
class MockODFService : public ODFService {
|
||||
public:
|
||||
MOCK_METHOD(std::vector<RackListResponse>, list_racks, (), (override));
|
||||
MOCK_METHOD(std::optional<RackResponse>, get_rack, (const std::string& rack_id), (override));
|
||||
MOCK_METHOD(RackResponse, create_rack, (const RackCreate& body), (override));
|
||||
MOCK_METHOD(bool, delete_rack, (const std::string& rack_id), (override));
|
||||
MOCK_METHOD(std::optional<UnitResponse>, create_unit, (const std::string& rack_id, const UnitCreate& body), (override));
|
||||
MOCK_METHOD(bool, delete_unit, (const std::string& unit_id), (override));
|
||||
MOCK_METHOD(std::vector<FreePortResponse>, get_free_ports, (const std::optional<std::string>& rack_id), (override));
|
||||
MOCK_METHOD(std::optional<PortDetail>, get_port_detail, (const std::string& port_id), (override));
|
||||
MOCK_METHOD(std::vector<ConnectionResponse>, list_connections, (), (override));
|
||||
MOCK_METHOD(std::optional<ConnectionResponse>, create_connection, (const ConnectionCreate& body), (override));
|
||||
MOCK_METHOD(bool, delete_connection, (const std::string& connection_id), (override));
|
||||
MOCK_METHOD(std::optional<std::string>, get_port_path, (const std::string& port_id), (override));
|
||||
MOCK_METHOD(std::string, health_check, (), (override));
|
||||
};
|
||||
|
||||
// ==================== 测试夹具 ====================
|
||||
|
||||
class ODFServiceTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
mock_service = std::make_shared<MockODFService>();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
mock_service.reset();
|
||||
}
|
||||
|
||||
std::shared_ptr<MockODFService> mock_service;
|
||||
};
|
||||
|
||||
// ==================== 机架 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testListRacksNormal) {
|
||||
std::vector<RackListResponse> expected = {
|
||||
{"rack1", "Rack A", 3},
|
||||
{"rack2", "Rack B", 0}
|
||||
};
|
||||
EXPECT_CALL(*mock_service, list_racks())
|
||||
.WillOnce(::testing::Return(expected));
|
||||
|
||||
auto result = mock_service->list_racks();
|
||||
ASSERT_EQ(result.size(), 2);
|
||||
EXPECT_EQ(result[0].rack_id, "rack1");
|
||||
EXPECT_EQ(result[1].unit_count, 0);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testListRacksEmpty) {
|
||||
EXPECT_CALL(*mock_service, list_racks())
|
||||
.WillOnce(::testing::Return(std::vector<RackListResponse>{}));
|
||||
|
||||
auto result = mock_service->list_racks();
|
||||
EXPECT_TRUE(result.empty());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetRackExists) {
|
||||
RackResponse rack;
|
||||
rack.rack_id = "rack1";
|
||||
rack.rack_name = "Main Rack";
|
||||
EXPECT_CALL(*mock_service, get_rack("rack1"))
|
||||
.WillOnce(::testing::Return(std::optional<RackResponse>(rack)));
|
||||
|
||||
auto result = mock_service->get_rack("rack1");
|
||||
ASSERT_TRUE(result.has_value());
|
||||
EXPECT_EQ(result->rack_id, "rack1");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetRackNotFound) {
|
||||
EXPECT_CALL(*mock_service, get_rack("invalid"))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->get_rack("invalid");
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateRackNormal) {
|
||||
RackCreate body{"New Rack", "Room 101"};
|
||||
RackResponse expected;
|
||||
expected.rack_id = "rack_new";
|
||||
expected.rack_name = "New Rack";
|
||||
expected.location = "Room 101";
|
||||
|
||||
EXPECT_CALL(*mock_service, create_rack(body))
|
||||
.WillOnce(::testing::Return(expected));
|
||||
|
||||
auto result = mock_service->create_rack(body);
|
||||
EXPECT_EQ(result.rack_name, "New Rack");
|
||||
EXPECT_EQ(result.location, "Room 101");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateRackEmptyName) {
|
||||
RackCreate body{"", "Location"};
|
||||
EXPECT_CALL(*mock_service, create_rack(body))
|
||||
.WillOnce(::testing::Throw(std::invalid_argument("rack_name cannot be empty")));
|
||||
|
||||
EXPECT_THROW(mock_service->create_rack(body), std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteRackSuccess) {
|
||||
EXPECT_CALL(*mock_service, delete_rack("rack1"))
|
||||
.WillOnce(::testing::Return(true));
|
||||
|
||||
EXPECT_TRUE(mock_service->delete_rack("rack1"));
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteRackNotFound) {
|
||||
EXPECT_CALL(*mock_service, delete_rack("ghost"))
|
||||
.WillOnce(::testing::Return(false));
|
||||
|
||||
EXPECT_FALSE(mock_service->delete_rack("ghost"));
|
||||
}
|
||||
|
||||
// ==================== 配线单元 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateUnitNormal) {
|
||||
UnitCreate body{1, "Unit 1", 1, 12, PortType::SC};
|
||||
UnitResponse unit;
|
||||
unit.unit_id = "unit1";
|
||||
unit.unit_number = 1;
|
||||
unit.unit_name = "Unit 1";
|
||||
unit.position = 1;
|
||||
unit.ports = std::vector<PortResponse>(12);
|
||||
|
||||
EXPECT_CALL(*mock_service, create_unit("rack1", body))
|
||||
.WillOnce(::testing::Return(std::optional<UnitResponse>(unit)));
|
||||
|
||||
auto result = mock_service->create_unit("rack1", body);
|
||||
ASSERT_TRUE(result.has_value());
|
||||
EXPECT_EQ(result->unit_number, 1);
|
||||
EXPECT_EQ(result->ports.size(), 12);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateUnitRackNotFound) {
|
||||
UnitCreate body{1, "Unit 1", 1, 12, PortType::LC};
|
||||
EXPECT_CALL(*mock_service, create_unit("bad_rack", body))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->create_unit("bad_rack", body);
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateUnitInvalidPortCount) {
|
||||
UnitCreate body{1, "Unit 1", 1, 0, PortType::FC};
|
||||
EXPECT_CALL(*mock_service, create_unit("rack1", body))
|
||||
.WillOnce(::testing::Throw(std::invalid_argument("port_count must be positive")));
|
||||
|
||||
EXPECT_THROW(mock_service->create_unit("rack1", body), std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteUnitSuccess) {
|
||||
EXPECT_CALL(*mock_service, delete_unit("unit1"))
|
||||
.WillOnce(::testing::Return(true));
|
||||
|
||||
EXPECT_TRUE(mock_service->delete_unit("unit1"));
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteUnitNotFound) {
|
||||
EXPECT_CALL(*mock_service, delete_unit("unknown"))
|
||||
.WillOnce(::testing::Return(false));
|
||||
|
||||
EXPECT_FALSE(mock_service->delete_unit("unknown"));
|
||||
}
|
||||
|
||||
// ==================== 端口 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testGetFreePortsAll) {
|
||||
std::vector<FreePortResponse> ports = {
|
||||
{"port1", "rack1", 1, 1, PortType::SC},
|
||||
{"port2", "rack1", 1, 2, PortType::SC}
|
||||
};
|
||||
EXPECT_CALL(*mock_service, get_free_ports(std::nullopt))
|
||||
.WillOnce(::testing::Return(ports));
|
||||
|
||||
auto result = mock_service->get_free_ports(std::nullopt);
|
||||
ASSERT_EQ(result.size(), 2);
|
||||
EXPECT_EQ(result[0].port_id, "port1");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetFreePortsFilterByRack) {
|
||||
std::vector<FreePortResponse> ports = {
|
||||
{"port3", "rack2", 2, 1, PortType::LC}
|
||||
};
|
||||
EXPECT_CALL(*mock_service, get_free_ports(std::optional<std::string>("rack2")))
|
||||
.WillOnce(::testing::Return(ports));
|
||||
|
||||
auto result = mock_service->get_free_ports("rack2");
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
EXPECT_EQ(result[0].rack_id, "rack2");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetFreePortsRackNotFound) {
|
||||
EXPECT_CALL(*mock_service, get_free_ports(std::optional<std::string>("ghost")))
|
||||
.WillOnce(::testing::Return(std::vector<FreePortResponse>{}));
|
||||
|
||||
auto result = mock_service->get_free_ports("ghost");
|
||||
EXPECT_TRUE(result.empty());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetPortDetailExists) {
|
||||
PortDetail detail{"port1", 1, PortType::SC, "FREE", "unit1", "rack1"};
|
||||
EXPECT_CALL(*mock_service, get_port_detail("port1"))
|
||||
.WillOnce(::testing::Return(std::optional<PortDetail>(detail)));
|
||||
|
||||
auto result = mock_service->get_port_detail("port1");
|
||||
ASSERT_TRUE(result.has_value());
|
||||
EXPECT_EQ(result->status, "FREE");
|
||||
EXPECT_EQ(result->rack_id, "rack1");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetPortDetailNotFound) {
|
||||
EXPECT_CALL(*mock_service, get_port_detail("bad_port"))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->get_port_detail("bad_port");
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
// ==================== 跳接连接 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testListConnectionsNormal) {
|
||||
std::vector<ConnectionResponse> conns = {
|
||||
{"conn1", "port1", "port2", 10.5, "test"}
|
||||
};
|
||||
EXPECT_CALL(*mock_service, list_connections())
|
||||
.WillOnce(::testing::Return(conns));
|
||||
|
||||
auto result = mock_service->list_connections();
|
||||
ASSERT_EQ(result.size(), 1);
|
||||
EXPECT_EQ(result[0].connection_id, "conn1");
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testListConnectionsEmpty) {
|
||||
EXPECT_CALL(*mock_service, list_connections())
|
||||
.WillOnce(::testing::Return(std::vector<ConnectionResponse>{}));
|
||||
|
||||
auto result = mock_service->list_connections();
|
||||
EXPECT_TRUE(result.empty());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateConnectionNormal) {
|
||||
ConnectionCreate body{"port1", "port2", 5.0, "link"};
|
||||
ConnectionResponse conn{"conn1", "port1", "port2", 5.0, "link"};
|
||||
EXPECT_CALL(*mock_service, create_connection(body))
|
||||
.WillOnce(::testing::Return(std::optional<ConnectionResponse>(conn)));
|
||||
|
||||
auto result = mock_service->create_connection(body);
|
||||
ASSERT_TRUE(result.has_value());
|
||||
EXPECT_EQ(result->fiber_length, 5.0);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateConnectionSamePort) {
|
||||
ConnectionCreate body{"port1", "port1", 1.0, ""};
|
||||
EXPECT_CALL(*mock_service, create_connection(body))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->create_connection(body);
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testCreateConnectionPortNotFree) {
|
||||
ConnectionCreate body{"port1", "port3", 2.0, ""};
|
||||
EXPECT_CALL(*mock_service, create_connection(body))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->create_connection(body);
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteConnectionSuccess) {
|
||||
EXPECT_CALL(*mock_service, delete_connection("conn1"))
|
||||
.WillOnce(::testing::Return(true));
|
||||
|
||||
EXPECT_TRUE(mock_service->delete_connection("conn1"));
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testDeleteConnectionNotFound) {
|
||||
EXPECT_CALL(*mock_service, delete_connection("bad_conn"))
|
||||
.WillOnce(::testing::Return(false));
|
||||
|
||||
EXPECT_FALSE(mock_service->delete_connection("bad_conn"));
|
||||
}
|
||||
|
||||
// ==================== 路径查询 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testGetPortPathExists) {
|
||||
std::string path_info = "port1 -> conn1 -> port2";
|
||||
EXPECT_CALL(*mock_service, get_port_path("port1"))
|
||||
.WillOnce(::testing::Return(std::optional<std::string>(path_info)));
|
||||
|
||||
auto result = mock_service->get_port_path("port1");
|
||||
ASSERT_TRUE(result.has_value());
|
||||
EXPECT_EQ(*result, path_info);
|
||||
}
|
||||
|
||||
TEST_F(ODFServiceTest, testGetPortPathNotFound) {
|
||||
EXPECT_CALL(*mock_service, get_port_path("unknown"))
|
||||
.WillOnce(::testing::Return(std::nullopt));
|
||||
|
||||
auto result = mock_service->get_port_path("unknown");
|
||||
EXPECT_FALSE(result.has_value());
|
||||
}
|
||||
|
||||
// ==================== 健康检查 API 测试 ====================
|
||||
|
||||
TEST_F(ODFServiceTest, testHealthCheck) {
|
||||
EXPECT_CALL(*mock_service, health_check())
|
||||
.WillOnce(::testing::Return("{\"status\": \"ok\"}"));
|
||||
|
||||
auto result = mock_service->health_check();
|
||||
EXPECT_NE(result.find("ok"), std::string::npos);
|
||||
}
|
||||
|
|
@ -0,0 +1,259 @@
|
|||
#include <gtest/gtest.h>
|
||||
#include "odf_service.h"
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
using namespace odf; // 假设模型和服务在 odf 命名空间
|
||||
|
||||
class OdfServiceTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
service = std::make_unique<OdfService>();
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
service.reset();
|
||||
}
|
||||
|
||||
std::unique_ptr<OdfService> service;
|
||||
};
|
||||
|
||||
// 测试构造函数和演示数据初始化
|
||||
TEST_F(OdfServiceTest, ConstructorInitializesDemoData) {
|
||||
// 验证初始化后机架数量为2
|
||||
auto racks = service->list_racks();
|
||||
EXPECT_EQ(racks.size(), 2);
|
||||
EXPECT_EQ(racks[0]["rack_name"], "ODF-001");
|
||||
EXPECT_EQ(racks[1]["rack_name"], "ODF-002");
|
||||
|
||||
// 验证机架1包含2个单元
|
||||
auto rack1 = service->get_rack("rack-001");
|
||||
ASSERT_NE(rack1, nullptr);
|
||||
EXPECT_EQ(rack1->units.size(), 2);
|
||||
|
||||
// 验证存在一条示例连接
|
||||
auto connections = service->list_connections();
|
||||
EXPECT_EQ(connections.size(), 1);
|
||||
}
|
||||
|
||||
// 测试 list_racks 正常返回
|
||||
TEST_F(OdfServiceTest, ListRacksReturnsAllRacks) {
|
||||
auto racks = service->list_racks();
|
||||
EXPECT_GE(racks.size(), 2);
|
||||
for (const auto& rack : racks) {
|
||||
EXPECT_TRUE(rack.find("rack_id") != rack.end());
|
||||
EXPECT_TRUE(rack.find("rack_name") != rack.end());
|
||||
EXPECT_TRUE(rack.find("location") != rack.end());
|
||||
EXPECT_TRUE(rack.find("unit_count") != rack.end());
|
||||
}
|
||||
}
|
||||
|
||||
// 测试 get_rack 存在和不存在的情况
|
||||
TEST_F(OdfServiceTest, GetRackValidIdReturnsRack) {
|
||||
auto rack = service->get_rack("rack-001");
|
||||
ASSERT_NE(rack, nullptr);
|
||||
EXPECT_EQ(rack->rack_name, "ODF-001");
|
||||
EXPECT_EQ(rack->location, "A机房-1列-01排");
|
||||
EXPECT_EQ(rack->units.size(), 2);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetRackInvalidIdReturnsNull) {
|
||||
auto rack = service->get_rack("non-existent");
|
||||
EXPECT_EQ(rack, nullptr);
|
||||
}
|
||||
|
||||
// 测试 create_rack 正常创建
|
||||
TEST_F(OdfServiceTest, CreateRackReturnsNewRack) {
|
||||
auto rack = service->create_rack("ODF-003", "B机房-2列-03排");
|
||||
ASSERT_NE(rack, nullptr);
|
||||
EXPECT_EQ(rack->rack_name, "ODF-003");
|
||||
EXPECT_EQ(rack->location, "B机房-2列-03排");
|
||||
EXPECT_TRUE(rack->units.empty());
|
||||
|
||||
// 验证机架已加入列表
|
||||
auto racks = service->list_racks();
|
||||
EXPECT_EQ(racks.size(), 3);
|
||||
}
|
||||
|
||||
// 测试 delete_rack 存在和不存在的情况
|
||||
TEST_F(OdfServiceTest, DeleteRackExistingReturnsTrue) {
|
||||
EXPECT_TRUE(service->delete_rack("rack-001"));
|
||||
EXPECT_EQ(service->get_rack("rack-001"), nullptr);
|
||||
// 验证关联的单元和端口也被删除
|
||||
EXPECT_EQ(service->get_free_ports("rack-001").size(), 0);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, DeleteRackNonExistentReturnsFalse) {
|
||||
EXPECT_FALSE(service->delete_rack("ghost-rack"));
|
||||
}
|
||||
|
||||
// 测试 create_unit 正常和机架不存在
|
||||
TEST_F(OdfServiceTest, CreateUnitInExistingRackReturnsUnit) {
|
||||
auto unit = service->create_unit("rack-001", 3, "测试单元", "中间", 8, PortType::LC);
|
||||
ASSERT_NE(unit, nullptr);
|
||||
EXPECT_EQ(unit->unit_number, 3);
|
||||
EXPECT_EQ(unit->ports.size(), 8);
|
||||
// 验证机架单元数增加
|
||||
auto rack = service->get_rack("rack-001");
|
||||
EXPECT_EQ(rack->units.size(), 3);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, CreateUnitInNonExistentRackReturnsNull) {
|
||||
auto unit = service->create_unit("bad-rack", 1, "测试", "上", 4, PortType::SC);
|
||||
EXPECT_EQ(unit, nullptr);
|
||||
}
|
||||
|
||||
// 测试 delete_unit 存在和不存在
|
||||
TEST_F(OdfServiceTest, DeleteUnitExistingReturnsTrue) {
|
||||
// 获取一个已存在的单元ID
|
||||
auto rack = service->get_rack("rack-001");
|
||||
ASSERT_FALSE(rack->units.empty());
|
||||
std::string unit_id = rack->units[0].unit_id;
|
||||
EXPECT_TRUE(service->delete_unit(unit_id));
|
||||
// 验证单元已移除
|
||||
EXPECT_EQ(service->get_rack("rack-001")->units.size(), 1);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, DeleteUnitNonExistentReturnsFalse) {
|
||||
EXPECT_FALSE(service->delete_unit("fake-unit-id"));
|
||||
}
|
||||
|
||||
// 测试 get_free_ports 无过滤和按机架过滤
|
||||
TEST_F(OdfServiceTest, GetFreePortsReturnsAllFreePorts) {
|
||||
auto ports = service->get_free_ports();
|
||||
// 演示数据中除了一条连接的两个端口外，其余都是空闲
|
||||
EXPECT_GT(ports.size(), 0);
|
||||
for (const auto& p : ports) {
|
||||
EXPECT_EQ(p["status"], "FREE");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetFreePortsFilterByRack) {
|
||||
auto ports = service->get_free_ports("rack-002");
|
||||
EXPECT_GT(ports.size(), 0);
|
||||
for (const auto& p : ports) {
|
||||
EXPECT_EQ(p["rack_id"], "rack-002");
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetFreePortsNonExistentRackReturnsEmpty) {
|
||||
auto ports = service->get_free_ports("no-rack");
|
||||
EXPECT_TRUE(ports.empty());
|
||||
}
|
||||
|
||||
// 测试 get_port_detail 存在和不存在
|
||||
TEST_F(OdfServiceTest, GetPortDetailValidIdReturnsInfo) {
|
||||
// 获取一个已知空闲端口
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_FALSE(free_ports.empty());
|
||||
std::string port_id = free_ports[0]["port_id"];
|
||||
auto detail = service->get_port_detail(port_id);
|
||||
ASSERT_TRUE(detail.has_value());
|
||||
EXPECT_EQ(detail->at("port_id"), port_id);
|
||||
EXPECT_EQ(detail->at("status"), "FREE");
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetPortDetailInvalidIdReturnsNullOpt) {
|
||||
auto detail = service->get_port_detail("bad-port");
|
||||
EXPECT_FALSE(detail.has_value());
|
||||
}
|
||||
|
||||
// 测试 create_connection 正常、端口不存在、端口繁忙、相同端口
|
||||
TEST_F(OdfServiceTest, CreateConnectionWithFreePortsSucceeds) {
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_GE(free_ports.size(), 2);
|
||||
std::string port_a = free_ports[0]["port_id"];
|
||||
std::string port_b = free_ports[1]["port_id"];
|
||||
auto conn = service->create_connection(port_a, port_b, 10.0, "测试连接");
|
||||
ASSERT_NE(conn, nullptr);
|
||||
EXPECT_EQ(conn->fiber_length, 10.0);
|
||||
EXPECT_EQ(conn->remark, "测试连接");
|
||||
// 验证端口状态变为 IN_USE
|
||||
auto detail_a = service->get_port_detail(port_a);
|
||||
EXPECT_EQ(detail_a->at("status"), "IN_USE");
|
||||
auto detail_b = service->get_port_detail(port_b);
|
||||
EXPECT_EQ(detail_b->at("status"), "IN_USE");
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, CreateConnectionWithNonExistentPortReturnsNull) {
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_FALSE(free_ports.empty());
|
||||
std::string port_a = free_ports[0]["port_id"];
|
||||
auto conn = service->create_connection(port_a, "ghost-port", 5.0, "");
|
||||
EXPECT_EQ(conn, nullptr);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, CreateConnectionWithBusyPortReturnsNull) {
|
||||
// 获取已使用的端口（演示数据中已有一条连接）
|
||||
auto connections = service->list_connections();
|
||||
ASSERT_FALSE(connections.empty());
|
||||
std::string busy_port = connections[0].port_a_id;
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_FALSE(free_ports.empty());
|
||||
std::string free_port = free_ports[0]["port_id"];
|
||||
auto conn = service->create_connection(busy_port, free_port, 1.0, "");
|
||||
EXPECT_EQ(conn, nullptr);
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, CreateConnectionSamePortReturnsNull) {
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_FALSE(free_ports.empty());
|
||||
std::string port = free_ports[0]["port_id"];
|
||||
auto conn = service->create_connection(port, port, 1.0, "");
|
||||
EXPECT_EQ(conn, nullptr);
|
||||
}
|
||||
|
||||
// 测试 list_connections
|
||||
TEST_F(OdfServiceTest, ListConnectionsReturnsAllConnections) {
|
||||
auto connections = service->list_connections();
|
||||
EXPECT_EQ(connections.size(), 1); // 演示数据有一条
|
||||
// 新增一条
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_GE(free_ports.size(), 2);
|
||||
service->create_connection(free_ports[0]["port_id"], free_ports[1]["port_id"], 2.0, "");
|
||||
connections = service->list_connections();
|
||||
EXPECT_EQ(connections.size(), 2);
|
||||
}
|
||||
|
||||
// 测试 delete_connection 存在和不存在
|
||||
TEST_F(OdfServiceTest, DeleteConnectionExistingReturnsTrue) {
|
||||
auto connections = service->list_connections();
|
||||
ASSERT_FALSE(connections.empty());
|
||||
std::string conn_id = connections[0].connection_id;
|
||||
EXPECT_TRUE(service->delete_connection(conn_id));
|
||||
EXPECT_TRUE(service->list_connections().empty());
|
||||
// 验证端口恢复空闲
|
||||
auto detail_a = service->get_port_detail(connections[0].port_a_id);
|
||||
EXPECT_EQ(detail_a->at("status"), "FREE");
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, DeleteConnectionNonExistentReturnsFalse) {
|
||||
EXPECT_FALSE(service->delete_connection("no-conn"));
|
||||
}
|
||||
|
||||
// 测试 get_port_path 存在和不存在
|
||||
TEST_F(OdfServiceTest, GetPortPathForConnectedPortReturnsPath) {
|
||||
auto connections = service->list_connections();
|
||||
ASSERT_FALSE(connections.empty());
|
||||
std::string port_id = connections[0].port_a_id;
|
||||
auto path = service->get_port_path(port_id);
|
||||
ASSERT_TRUE(path.has_value());
|
||||
EXPECT_EQ(path->at("port")["port_id"], port_id);
|
||||
EXPECT_TRUE(path->at("connection").has_value());
|
||||
EXPECT_TRUE(path->at("connected_port").has_value());
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetPortPathForFreePortReturnsNoConnection) {
|
||||
auto free_ports = service->get_free_ports();
|
||||
ASSERT_FALSE(free_ports.empty());
|
||||
std::string port_id = free_ports[0]["port_id"];
|
||||
auto path = service->get_port_path(port_id);
|
||||
ASSERT_TRUE(path.has_value());
|
||||
EXPECT_FALSE(path->at("connection").has_value());
|
||||
EXPECT_FALSE(path->at("connected_port").has_value());
|
||||
}
|
||||
|
||||
TEST_F(OdfServiceTest, GetPortPathInvalidPortReturnsNullOpt) {
|
||||
auto path = service->get_port_path("invalid");
|
||||
EXPECT_FALSE(path.has_value());
|
||||
}
|
||||
Loading…
Reference in New Issue