Function test_worker_pool_concurrency_limit

src/server/worker_pool.rs:272–319

()

    #[tokio::test]
    async fn test_worker_pool_concurrency_limit() {
        let pool = WorkerPool::new(2);

        // Submit 3 jobs that take 100ms each
        let start = tokio::time::Instant::now();

        let mut submitted = 0;
        let mut attempts = 0;
        while submitted < 3 && attempts < 100 {
            let job = TestJob {
                id: format!("job-{}", submitted),
                duration_ms: 100,
                should_fail: false,
            };
            if pool.try_submit(job).await.unwrap().is_some() {
                submitted += 1;
            } else {
                // Wait a bit for a worker to become available
                sleep(Duration::from_millis(10)).await;
            }
            attempts += 1;
        }
        assert_eq!(submitted, 3, "Should have submitted all 3 jobs");

        // Wait for all jobs to complete
        sleep(Duration::from_millis(250)).await;

        // Poll for all completed jobs
        let mut total_completed = 0;
        loop {
            let completed = pool.poll_completed().await;
            total_completed += completed.len();
            if total_completed >= 3 {
                break;
            }
            sleep(Duration::from_millis(10)).await;
        }

        let elapsed = start.elapsed();

        // With 2 workers and 3 jobs of 100ms each, it should take ~200ms
        // (2 jobs run in parallel, then the 3rd runs)
        assert_eq!(total_completed, 3, "All 3 jobs should complete");
        assert!(
            elapsed >= Duration::from_millis(150),
            "Should take at least 150ms"
        );
    }

    #[tokio::test]
    async fn test_worker_pool_error_handling() {