Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

4.7 KB
Raw Blame
use super::*;
use async_trait::async_trait;
use std::sync::atomic::{AtomicUsize, Ordering};

struct WaitingRunner(AtomicUsize);

#[async_trait]
impl CodeRunner for WaitingRunner {
    async fn run(
        &self,
        job: ExecutionJob,
        _events: &mut EventSink,
        cancellation: CancellationToken,
    ) -> Outcome {
        self.0.fetch_add(1, Ordering::SeqCst);
        tokio::select! {
            _ = cancellation.cancelled() => Outcome::Cancelled,
            _ = sleep_until(job.deadline) => Outcome::TimedOut,
        }
    }
}

fn request(timeout_ms: u64) -> ExecuteRequest {
    ExecuteRequest {
        source: "return 42;".into(),
        timeout_ms,
    }
}

#[tokio::test]
async fn validates_before_admission_and_bounds_queue() {
    let runner = Arc::new(WaitingRunner(AtomicUsize::new(0)));
    let service = ExecutionService::new(
        runner.clone(),
        Limits {
            max_running: 1,
            max_queued: 1,
            ..Limits::default()
        },
    )
    .unwrap();
    assert!(matches!(
        service.execute(request(0), RunEnvironment::default()),
        Err(AdmissionError::InvalidTimeout)
    ));
    assert!(matches!(
        service.execute(request(30_001), RunEnvironment::default()),
        Err(AdmissionError::InvalidTimeout)
    ));
    assert!(matches!(
        service.execute(
            ExecuteRequest {
                source: " ".into(),
                timeout_ms: 1
            },
            RunEnvironment::default()
        ),
        Err(AdmissionError::InvalidSource)
    ));
    let mut first = service
        .execute(request(10_000), RunEnvironment::default())
        .unwrap();
    while !matches!(first.events.recv().await.unwrap().kind, EventKind::Started) {}
    let second = service
        .execute(request(10_000), RunEnvironment::default())
        .unwrap();
    assert!(matches!(
        service.execute(request(1), RunEnvironment::default()),
        Err(AdmissionError::Busy)
    ));
    assert_eq!(runner.0.load(Ordering::SeqCst), 1);
    drop(first);
    drop(second);
    service.shutdown().await;
    assert!(matches!(
        service.execute(request(1), RunEnvironment::default()),
        Err(AdmissionError::ShuttingDown)
    ));
}

#[tokio::test]
async fn queued_deadline_does_not_start_another_process() {
    let runner = Arc::new(WaitingRunner(AtomicUsize::new(0)));
    let service = ExecutionService::new(
        runner.clone(),
        Limits {
            max_running: 1,
            max_queued: 1,
            ..Limits::default()
        },
    )
    .unwrap();
    let mut first = service
        .execute(request(10_000), RunEnvironment::default())
        .unwrap();
    while !matches!(first.events.recv().await.unwrap().kind, EventKind::Started) {}
    let mut second = service
        .execute(request(20), RunEnvironment::default())
        .unwrap();
    let mut terminal = None;
    while let Some(event) = second.events.recv().await {
        if let EventKind::Finished { outcome } = event.kind {
            terminal = Some(outcome)
        }
    }
    assert!(matches!(terminal, Some(Outcome::TimedOut)));
    assert_eq!(runner.0.load(Ordering::SeqCst), 1);
    drop(first);
    service.shutdown().await;
}

#[test]
fn advisory_progress_cannot_consume_the_log_budget() {
    let (sender, mut receiver) = mpsc::channel(5);
    let mut sink = EventSink {
        run_id: RunId(uuid::Uuid::now_v7()),
        sender,
        sequence: 0,
        remaining: 2,
        remaining_progress: 2,
    };
    sink.progress(serde_json::json!({"event": 1}));
    sink.progress(serde_json::json!({"event": 2}));
    sink.emit(EventKind::Log {
        level: LogLevel::Info,
        message: "still works".into(),
    })
    .unwrap();
    sink.emit(EventKind::Log {
        level: LogLevel::Info,
        message: "second log".into(),
    })
    .unwrap();
    assert_eq!(receiver.try_recv().unwrap().sequence, 0);
    assert_eq!(receiver.try_recv().unwrap().sequence, 1);
    assert_eq!(receiver.try_recv().unwrap().sequence, 2);
    assert_eq!(receiver.try_recv().unwrap().sequence, 3);
    assert!(receiver.try_recv().is_err());
}

#[test]
fn result_budget_must_fit_in_a_frame() {
    assert!(matches!(
        Limits {
            max_frame_bytes: 16 * 1024,
            ..Limits::default()
        }
        .validate(),
        Err(AdmissionError::InvalidLimits)
    ));
    assert!(matches!(
        Limits {
            max_frame_bytes: 16 * 1024,
            max_result_bytes: 16 * 1024,
            ..Limits::default()
        }
        .validate(),
        Err(AdmissionError::InvalidLimits)
    ));
    assert!(
        Limits {
            max_frame_bytes: 16 * 1024,
            max_result_bytes: 16 * 1024 - RESULT_FRAME_OVERHEAD,
            ..Limits::default()
        }
        .validate()
        .is_ok()
    );
}