CollisionAvoidanceSystem/src/test/java/com/dongni/collisionavoidance/config/TestConfig.java

package com.dongni.collisionavoidance.config;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import com.dongni.collisionavoidance.common.model.MovingObject;
import com.dongni.collisionavoidance.common.model.MovingObjectType;
import com.dongni.collisionavoidance.common.model.repository.MovingObjectRepository;
import com.dongni.collisionavoidance.dataCollector.service.AuthService;
import com.dongni.collisionavoidance.dataCollector.service.DataCollectorService;
import com.dongni.collisionavoidance.dataProcessing.service.CoordinateSystemService;
import com.dongni.collisionavoidance.dataProcessing.service.DataProcessor;
import com.dongni.collisionavoidance.dataProcessing.service.SpeedCalculationService;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Executor;
import org.springframework.web.client.RestTemplate;

/**
 * 测试专用配置类，用于禁用后台线程和外部连接
 */
@Configuration
@Profile("test")
public class TestConfig {
    
    /**
     * 提供一个测试专用的线程池，会立即关闭而不会等待任务执行完成
     */
    @Bean(name = "processingExecutor")
    @Primary
    public Executor testProcessingExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(1);
        executor.setWaitForTasksToCompleteOnShutdown(false);
        executor.setAwaitTerminationSeconds(1);
        executor.setThreadNamePrefix("test-proc-");
        return executor;
    }
    
    /**
     * 提供一个用于调度的线程池，会立即关闭而不会等待任务执行完成
     */
    @Bean
    @Primary
    public ThreadPoolTaskScheduler testTaskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(1);
        scheduler.setThreadNamePrefix("test-sched-");
        scheduler.setWaitForTasksToCompleteOnShutdown(false);
        scheduler.setAwaitTerminationSeconds(1);
        return scheduler;
    }
    
    /**
     * 提供一个不执行任何操作的数据处理器
     */
    @Bean
    @Primary
    public DataProcessor noOpDataProcessor(MovingObjectRepository movingObjectRepository, 
                                         CoordinateSystemService coordinateSystemService,
                                         SpeedCalculationService speedCalculationService,
                                         Executor processingExecutor) {
        return new TestDataProcessor(movingObjectRepository, coordinateSystemService, 
                                   speedCalculationService, processingExecutor);
    }
    
    /**
     * 提供一个不进行HTTP请求的测试用认证服务
     */
    @Bean
    @Primary
    public AuthService testAuthService(RestTemplate restTemplate) {
        return new TestAuthService(restTemplate);
    }
    
    /**
     * 提供一个不调用外部API的数据采集服务
     */
    @Bean
    @Primary
    public DataCollectorService testDataCollectorService() {
        return new TestDataCollectorService();
    }
    
    /**
     * 测试用数据处理器实现，不会启动实际的处理线程
     */
    static class TestDataProcessor extends DataProcessor {
        public TestDataProcessor(MovingObjectRepository movingObjectRepository,
                              CoordinateSystemService coordinateSystemService,
                              SpeedCalculationService speedCalculationService,
                              Executor processingExecutor) {
            super();
            // 注入依赖，但不启动后台线程
        }
        
        @Override
        public void init() {
            // 不启动处理线程
        }
    }
    
    /**
     * 测试用认证服务实现，返回固定的测试令牌
     */
    static class TestAuthService extends AuthService {
        public TestAuthService(RestTemplate restTemplate) {
            super(restTemplate);
        }
        
        @Override
        public String loginAndGetToken() {
            return "test-token";
        }
        
        @Override
        public String refreshToken() {
            return "test-token";
        }
        
        @Override
        public String getToken() {
            return "test-token";
        }
    }
    
    /**
     * 测试用数据采集服务，不执行实际的数据采集
     */
    static class TestDataCollectorService extends DataCollectorService {
        // 覆盖所有定时任务方法，不执行实际操作
        @Override
        public void collectAircraftData() {
            // 测试环境下不执行实际数据采集
        }
        
        @Override
        public void collectVehicleData() {
            // 测试环境下不执行实际数据采集
        }
    }
}