CollisionAvoidance/tests/HTTPDataSourceTest.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "network/HTTPDataSource.h"
#include "utils/Logger.h"

class HTTPDataSourceTest : public ::testing::Test {
protected:
    std::unique_ptr<HTTPDataSource> source;
    
    void SetUp() override {
        DataSourceConfig config;
        config.host = "localhost";
        config.port = 8081;
        config.aircraft_path = "/api/getCurrentFlightPositions";
        config.vehicle_path = "/api/getCurrentVehiclePositions";
        config.traffic_light_path = "/api/getTrafficLightSignals";
        source = std::make_unique<HTTPDataSource>(config);
    }
    
    void TearDown() override {
        source.reset();
    }
};

TEST_F(HTTPDataSourceTest, ConnectTest) {
    EXPECT_FALSE(source->isAvailable());  // 初始状态应该是未连接
    EXPECT_TRUE(source->connect());       // 连接应该成功
    EXPECT_TRUE(source->isAvailable());   // 连接后应该可用
}

TEST_F(HTTPDataSourceTest, DisconnectTest) {
    source->connect();
    EXPECT_TRUE(source->isAvailable());
    source->disconnect();
    EXPECT_FALSE(source->isAvailable());
}

TEST_F(HTTPDataSourceTest, FetchAircraftDataTest) {
    std::vector<Aircraft> aircraft;
    
    // 尝试连接
    bool connected = source->connect();
    Logger::info("Connection result: ", connected ? "success" : "failed");
    EXPECT_TRUE(connected);
    
    // 检查连接状态
    bool available = source->isAvailable();
    Logger::info("Connection available: ", available ? "yes" : "no");
    EXPECT_TRUE(available);
    
    // 获取数据
    bool fetchResult = source->fetchAircraftData(aircraft);
    Logger::info("Fetch result: ", fetchResult ? "success" : "failed");
    EXPECT_TRUE(fetchResult);
    
    // 检查数据
    Logger::info("Aircraft data size: ", aircraft.size());
    EXPECT_FALSE(aircraft.empty());
}

TEST_F(HTTPDataSourceTest, FetchVehicleDataTest) {
    std::vector<Vehicle> vehicles;
    EXPECT_TRUE(source->connect());  // 确保连接成功
    EXPECT_TRUE(source->fetchVehicleData(vehicles));
    EXPECT_FALSE(vehicles.empty());
}

TEST_F(HTTPDataSourceTest, FetchTrafficLightSignalsTest) {
    std::vector<TrafficLightSignal> signals;
    EXPECT_TRUE(source->connect());  // 确保连接成功
    EXPECT_TRUE(source->fetchTrafficLightSignals(signals));
    EXPECT_FALSE(signals.empty());
}

TEST_F(HTTPDataSourceTest, CustomPathTest) {
    // 测试使用自定义路径创建数据源
    DataSourceConfig config;
    config.host = "localhost";
    config.port = 8081;
    config.aircraft_path = "/custom/path";
    auto customSource = std::make_unique<HTTPDataSource>(config);
    EXPECT_TRUE(customSource->connect());
    EXPECT_TRUE(customSource->isAvailable());
}

TEST_F(HTTPDataSourceTest, ConnectionFailureTest) {
    // 测试连接到不存在的服务器
    DataSourceConfig config;
    config.host = "localhost";  // 使用本地地址
    config.port = 1;  // 使用一个通常不会被使用的端口
    auto invalidSource = std::make_unique<HTTPDataSource>(config);
    EXPECT_FALSE(invalidSource->connect());
    EXPECT_FALSE(invalidSource->isAvailable());
}

TEST_F(HTTPDataSourceTest, FetchDataWithoutConnectionTest) {
    // 测试在未连接状态下获取数据
    std::vector<Aircraft> aircraft;
    std::vector<Vehicle> vehicles;
    std::vector<TrafficLightSignal> signals;
    
    // 配置一个很短的刷新间隔，这样重连会快速失败
    DataSourceConfig config;
    config.host = "localhost";
    config.port = 1;  // 使用一个通常不会被使用的端口
    config.refresh_interval_ms = 1;  // 设置很短的刷新间隔
    source = std::make_unique<HTTPDataSource>(config);
    
    // 测试所有数据获取方法
    EXPECT_FALSE(source->fetchAircraftData(aircraft));
    EXPECT_FALSE(source->fetchVehicleData(vehicles));
    EXPECT_FALSE(source->fetchTrafficLightSignals(signals));
    
    // 验证数据集为空
    EXPECT_TRUE(aircraft.empty());
    EXPECT_TRUE(vehicles.empty());
    EXPECT_TRUE(signals.empty());
}

// 添加一个新的测试用例，专门测试重连机制
TEST_F(HTTPDataSourceTest, ReconnectionTest) {
    // 配置一个较短的刷新间隔
    DataSourceConfig config;
    config.host = "localhost";
    config.port = 1;  // 使用一个通常不会被使用的端口
    config.refresh_interval_ms = 100;  // 100毫秒的刷新间隔
    auto reconnectSource = std::make_unique<HTTPDataSource>(config);
    
    // 第一次连接应该失败
    EXPECT_FALSE(reconnectSource->connect());
    EXPECT_FALSE(reconnectSource->isAvailable());
    
    // 尝试获取数据，这会触发重连
    std::vector<Aircraft> aircraft;
    EXPECT_FALSE(reconnectSource->fetchAircraftData(aircraft));
    EXPECT_TRUE(aircraft.empty());
}

// 如果你的环境支持模拟网络响应，可以添加更多测试
TEST_F(HTTPDataSourceTest, InvalidResponseTest) {
    // 这个测试需要模拟无效的服务器响应
    // 你可能需要使用 mock 对象或者设置一个返回无效数据的测试服务器
    source->connect();
    std::vector<Aircraft> aircraft;
    // 假设服务器返回无效的 JSON 数据
    // EXPECT_FALSE(source->fetchAircraftData(aircraft));
}

// 测试不同的超时配置
TEST_F(HTTPDataSourceTest, DifferentTimeoutConfigTest) {
    // 测试读取超时小于连接超时
    {
        DataSourceConfig config;
        config.host = "localhost";
        config.port = 8081;
        config.timeout_ms = 5000;      // 连接超时 5 秒
        config.read_timeout_ms = 2000;  // 读取超时 2 秒
        
        auto source = std::make_unique<HTTPDataSource>(config);
        EXPECT_FALSE(source->isAvailable());  // 只验证初始状态
        
        std::vector<Aircraft> aircraft;
        EXPECT_FALSE(source->fetchAircraftData(aircraft));
        EXPECT_TRUE(aircraft.empty());
    }
    
    // 测试读取超时等于连接超时
    {
        DataSourceConfig config;
        config.host = "localhost";
        config.port = 8081;
        config.timeout_ms = 5000;     // 连接超时 5 秒
        config.read_timeout_ms = 5000; // 读取超时 5 秒
        
        auto source = std::make_unique<HTTPDataSource>(config);
        EXPECT_FALSE(source->isAvailable());  // 只验证初始状态
        
        std::vector<Aircraft> aircraft;
        EXPECT_FALSE(source->fetchAircraftData(aircraft));
        EXPECT_TRUE(aircraft.empty());
    }
}

// 修改读取超时测试
TEST_F(HTTPDataSourceTest, ReadTimeoutTest) {
    DataSourceConfig config;
    config.host = "localhost";
    config.port = 8081;
    config.timeout_ms = 5000;      // 连接超时 5 秒
    config.read_timeout_ms = 2000;  // 读取超时 2 秒
    
    auto source = std::make_unique<HTTPDataSource>(config);
    EXPECT_FALSE(source->isAvailable());  // 验证初始状态
    
    std::vector<Aircraft> aircraft;
    EXPECT_FALSE(source->fetchAircraftData(aircraft));
    EXPECT_TRUE(aircraft.empty());
}

// 修改连接健康和超时测试
TEST_F(HTTPDataSourceTest, ConnectionHealthAndTimeout) {
    DataSourceConfig config;
    config.host = "localhost";
    config.port = 8081;
    config.timeout_ms = 5000;      // 连接超时 5 秒
    config.read_timeout_ms = 2000;  // 读取超时 2 秒
    
    auto source = std::make_unique<HTTPDataSource>(config);
    EXPECT_FALSE(source->isAvailable());  // 验证初始状态
    
    std::vector<Aircraft> aircraft;
    EXPECT_FALSE(source->fetchAircraftData(aircraft));
    EXPECT_TRUE(aircraft.empty());
}