ODF/tests/test_odf_service.cpp

#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());
}