CollisionAvoidance/tests/DataCollectorTest.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "collector/DataCollector.h"
#include "network/ConnectionConfig.h"
#include "utils/Logger.h"

// 创建一个 Mock DataSource 类
class MockDataSource : public DataSource {
public:
    MOCK_METHOD(bool, connect, (), (override));
    MOCK_METHOD(void, disconnect, (), (override));
    MOCK_METHOD(bool, isAvailable, (), (const, override));
    MOCK_METHOD(bool, fetchAircraftData, (std::vector<Aircraft>&), (override));
    MOCK_METHOD(bool, fetchVehicleData, (std::vector<Vehicle>&), (override));
};

class DataCollectorTest : public ::testing::Test {
protected:
    void SetUp() override {
        collector = std::make_unique<DataCollector>();
    }

    void TearDown() override {
        collector.reset();
    }

    // 创建测试数据
    Aircraft createTestAircraft(const std::string& id, double lat, double lon) {
        Aircraft a;
        a.id = id;
        a.flightNo = id;
        a.trackNumber = "TN" + id;
        a.geo.latitude = lat;
        a.geo.longitude = lon;
        a.altitude = 5.0;
        a.timestamp = time(nullptr);
        return a;
    }

    Vehicle createTestVehicle(const std::string& id, double lat, double lon) {
        Vehicle v;
        v.id = id;
        v.vehicleNo = id;
        v.geo.latitude = lat;
        v.geo.longitude = lon;
        v.timestamp = time(nullptr);
        return v;
    }

    std::unique_ptr<DataCollector> collector;
};

// 测试初始化
TEST_F(DataCollectorTest, Initialization) {
    ConnectionConfig config{"localhost", 8080};
    EXPECT_TRUE(collector->initialize(config));
}

// 测试数据采集
TEST_F(DataCollectorTest, DataCollection) {
    // 创建 Mock DataSource
    auto mockSource = std::make_shared<::testing::NiceMock<MockDataSource>>();
    
    // 设置期望行为
    EXPECT_CALL(*mockSource, connect())
        .WillOnce(::testing::Return(true));
        
    std::vector<Aircraft> testAircraft = {
        createTestAircraft("TEST1", 36.36, 120.08),
        createTestAircraft("TEST2", 36.37, 120.09)
    };
    
    std::vector<Vehicle> testVehicles = {
        createTestVehicle("VEH1", 36.36, 120.08),
        createTestVehicle("VEH2", 36.37, 120.09)
    };
    
    // 设置 Mock 数据返回
    ON_CALL(*mockSource, fetchAircraftData)
        .WillByDefault([testAircraft](std::vector<Aircraft>& aircraft) {
            aircraft = testAircraft;
            return true;
        });
        
    ON_CALL(*mockSource, fetchVehicleData)
        .WillByDefault([testVehicles](std::vector<Vehicle>& vehicles) {
            vehicles = testVehicles;
            return true;
        });
    
    // 设置 Mock DataSource
    collector->setDataSource(mockSource);
    
    // 启动采集
    collector->start();
    
    // 等待数据采集
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    // 验证数据
    auto aircraft = collector->getAircraftData();
    EXPECT_EQ(aircraft.size(), 2);
    if (!aircraft.empty()) {
        EXPECT_EQ(aircraft[0].flightNo, "TEST1");
        EXPECT_EQ(aircraft[1].flightNo, "TEST2");
    }
    
    auto vehicles = collector->getVehicleData();
    EXPECT_EQ(vehicles.size(), 2);
    if (!vehicles.empty()) {
        EXPECT_EQ(vehicles[0].vehicleNo, "VEH1");
        EXPECT_EQ(vehicles[1].vehicleNo, "VEH2");
    }
    
    // 停止采集
    collector->stop();
}

// 测试速度计算
TEST_F(DataCollectorTest, SpeedCalculation) {
    auto mockSource = std::make_shared<::testing::NiceMock<MockDataSource>>();
    EXPECT_CALL(*mockSource, connect())
        .WillOnce(::testing::Return(true));
    
    uint64_t baseTime = time(nullptr);
    
    // 创建一系列连续的位置数据
    std::vector<std::vector<Aircraft>> positions;
    
    // 计算经度变化量
    // 在36.36°纬度，1度经度约等于90km
    // 要达到55m/s的速度，每秒需要变化：55/(90000) = 0.00061度
    const double LON_CHANGE_PER_SEC = 0.00061;  // 每秒经度变化量
    
    // 每秒一个位置点，总共10秒
    for (int i = 0; i < 10; i++) {
        double lon = 120.08 + (LON_CHANGE_PER_SEC * i);
        uint64_t timestamp = baseTime + (i * 1);  // 每秒一个点
        
        std::vector<Aircraft> data = {
            createTestAircraft("TEST1", 36.36, lon)
        };
        data[0].timestamp = timestamp;
        positions.push_back(data);
    }
    
    // 设置 Mock 数据返回
    int callCount = 0;
    ON_CALL(*mockSource, fetchAircraftData)
        .WillByDefault([positions, &callCount](std::vector<Aircraft>& aircraft) {
            if (callCount < positions.size()) {
                const auto& pos = positions[callCount];
                aircraft = pos;
                callCount++;
            } else {
                const auto& pos = positions.back();
                aircraft = pos;
            }
            return true;
        });
    
    collector->setDataSource(mockSource);
    collector->start();
    
    // 等待数据更新
    std::this_thread::sleep_for(std::chrono::seconds(3));
    
    // 验证速度计算
    auto aircraft = collector->getAircraftData();
    
    EXPECT_FALSE(aircraft.empty());
    if (!aircraft.empty()) {
        const auto& a = aircraft[0];
        
        // 总共移动约110米，用时2秒，期望速度约55米/秒
        EXPECT_NEAR(a.speed, 55.0, 5.0);
    }
    
    collector->stop();
}