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.

12.3 KB
Raw Blame
use super::*;
use crate::domain::models::{NormalizedWebhookEvent, WEBHOOK_EVENT_QUEUE_MESSAGE_VERSION};
use chrono::{DateTime, Utc};
use std::{
    collections::{HashSet, VecDeque},
    fmt,
    sync::{Arc, Mutex},
};
use tokio::time::Instant;

#[derive(Debug, Clone, Copy)]
struct TestError(&'static str);

impl fmt::Display for TestError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.0)
    }
}

impl std::error::Error for TestError {}

#[derive(Default)]
struct QueueState {
    receive_results: VecDeque<Result<Vec<RawWebhookEventQueueMessage>, TestError>>,
    receive_count: usize,
    delete_requests: Vec<String>,
    delay_requests: Vec<(String, Duration)>,
    failed_deletes: HashSet<String>,
    failed_delays: HashSet<String>,
    operations: Option<Arc<Mutex<Vec<String>>>>,
}

#[derive(Clone, Default)]
struct TestQueue {
    state: Arc<Mutex<QueueState>>,
}

impl TestQueue {
    fn with_receive_result(result: Result<Vec<RawWebhookEventQueueMessage>, TestError>) -> Self {
        let queue = Self::default();
        queue
            .state
            .lock()
            .expect("queue state lock")
            .receive_results
            .push_back(result);
        queue
    }

    fn fail_delete(&self, receipt_handle: &str) {
        self.state
            .lock()
            .expect("queue state lock")
            .failed_deletes
            .insert(receipt_handle.to_string());
    }

    fn fail_delay(&self, receipt_handle: &str) {
        self.state
            .lock()
            .expect("queue state lock")
            .failed_delays
            .insert(receipt_handle.to_string());
    }

    fn set_operations(&self, operations: Arc<Mutex<Vec<String>>>) {
        self.state.lock().expect("queue state lock").operations = Some(operations);
    }

    fn receive_count(&self) -> usize {
        self.state.lock().expect("queue state lock").receive_count
    }

    fn delete_requests(&self) -> Vec<String> {
        self.state
            .lock()
            .expect("queue state lock")
            .delete_requests
            .clone()
    }

    fn delay_requests(&self) -> Vec<(String, Duration)> {
        self.state
            .lock()
            .expect("queue state lock")
            .delay_requests
            .clone()
    }
}

impl WebhookEventQueue for TestQueue {
    type Err = TestError;

    async fn receive_messages(&self) -> Result<Vec<RawWebhookEventQueueMessage>, Self::Err> {
        let mut state = self.state.lock().expect("queue state lock");
        state.receive_count += 1;
        state.receive_results.pop_front().unwrap_or(Ok(Vec::new()))
    }

    async fn delete_message(&self, receipt_handle: &str) -> Result<(), Self::Err> {
        let mut state = self.state.lock().expect("queue state lock");
        state.delete_requests.push(receipt_handle.to_string());
        if let Some(operations) = &state.operations {
            operations
                .lock()
                .expect("operations lock")
                .push(format!("delete:{receipt_handle}"));
        }
        if state.failed_deletes.contains(receipt_handle) {
            return Err(TestError("delete failed"));
        }
        Ok(())
    }

    async fn delay_message(&self, receipt_handle: &str, delay: Duration) -> Result<(), Self::Err> {
        let mut state = self.state.lock().expect("queue state lock");
        state
            .delay_requests
            .push((receipt_handle.to_string(), delay));
        if state.failed_delays.contains(receipt_handle) {
            return Err(TestError("visibility update failed"));
        }
        Ok(())
    }
}

struct ServiceState {
    outcomes: VecDeque<Result<WebhookWorkerDisposition, TestError>>,
    messages: Vec<WebhookEventQueueMessage>,
    operations: Option<Arc<Mutex<Vec<String>>>>,
}

#[derive(Clone)]
struct TestDeliveryService {
    state: Arc<Mutex<ServiceState>>,
}

impl TestDeliveryService {
    fn new(
        outcomes: impl IntoIterator<Item = Result<WebhookWorkerDisposition, TestError>>,
    ) -> Self {
        Self {
            state: Arc::new(Mutex::new(ServiceState {
                outcomes: outcomes.into_iter().collect(),
                messages: Vec::new(),
                operations: None,
            })),
        }
    }

    fn set_operations(&self, operations: Arc<Mutex<Vec<String>>>) {
        self.state.lock().expect("service state lock").operations = Some(operations);
    }

    fn messages(&self) -> Vec<WebhookEventQueueMessage> {
        self.state
            .lock()
            .expect("service state lock")
            .messages
            .clone()
    }
}

impl WebhookEventDeliveryService for TestDeliveryService {
    type Err = TestError;

    async fn deliver_event(
        &self,
        message: WebhookEventQueueMessage,
    ) -> Result<WebhookWorkerDisposition, Self::Err> {
        let mut state = self.state.lock().expect("service state lock");
        if let Some(operations) = &state.operations {
            operations
                .lock()
                .expect("operations lock")
                .push(format!("service:{}", message.event.event_id));
        }
        state.messages.push(message);
        state
            .outcomes
            .pop_front()
            .expect("a delivery outcome for every valid test message")
    }
}

fn queue_message(event_id: &str) -> WebhookEventQueueMessage {
    WebhookEventQueueMessage::new(
        "wh_test".to_string(),
        NormalizedWebhookEvent {
            event_id: event_id.to_string(),
            schema_version: 1,
            event_name: "document.updated".to_string(),
            entity_type: "document".to_string(),
            entity_id: "doc_test".to_string(),
            ordering_key: "doc_test".to_string(),
            occurred_at: "2026-07-10T00:00:00Z"
                .parse::<DateTime<Utc>>()
                .expect("valid timestamp"),
            broker_envelope: serde_json::json!({"event_id": event_id}),
        },
    )
}

fn raw_message(
    message_id: &str,
    body: Option<String>,
    receipt_handle: Option<&str>,
) -> RawWebhookEventQueueMessage {
    RawWebhookEventQueueMessage {
        message_id: Some(message_id.to_string()),
        body,
        receipt_handle: receipt_handle.map(str::to_string),
    }
}

fn valid_raw_message(event_id: &str, receipt_handle: &str) -> RawWebhookEventQueueMessage {
    raw_message(
        event_id,
        Some(serde_json::to_string(&queue_message(event_id)).expect("serializable queue message")),
        Some(receipt_handle),
    )
}

#[tokio::test(start_paused = true)]
async fn empty_poll_sleeps_before_polling_again() {
    let queue = TestQueue::with_receive_result(Ok(Vec::new()));
    let worker = WebhookEventWorker::new(queue.clone(), TestDeliveryService::new([]));
    let started_at = Instant::now();

    worker.poll_and_process_batch().await;

    assert_eq!(Instant::now().duration_since(started_at), POLL_RETRY_DELAY);
    assert_eq!(queue.receive_count(), 1);
}

#[tokio::test(start_paused = true)]
async fn failed_poll_sleeps_before_polling_again() {
    let queue = TestQueue::with_receive_result(Err(TestError("receive failed")));
    let worker = WebhookEventWorker::new(queue.clone(), TestDeliveryService::new([]));
    let started_at = Instant::now();

    worker.poll_and_process_batch().await;

    assert_eq!(Instant::now().duration_since(started_at), POLL_RETRY_DELAY);
    assert_eq!(queue.receive_count(), 1);
}

#[tokio::test]
async fn acknowledges_missing_malformed_and_unsupported_messages() {
    let mut unsupported = queue_message("unsupported");
    unsupported.version = WEBHOOK_EVENT_QUEUE_MESSAGE_VERSION + 1;
    let messages = vec![
        raw_message("missing", None, Some("receipt-missing")),
        raw_message(
            "malformed",
            Some("not valid json".to_string()),
            Some("receipt-malformed"),
        ),
        raw_message(
            "unsupported",
            Some(serde_json::to_string(&unsupported).expect("serializable queue message")),
            Some("receipt-unsupported"),
        ),
    ];
    let queue = TestQueue::with_receive_result(Ok(messages));
    let service = TestDeliveryService::new([]);
    let worker = WebhookEventWorker::new(queue.clone(), service.clone());

    worker.poll_and_process_batch().await;

    assert_eq!(
        queue.delete_requests(),
        [
            "receipt-missing",
            "receipt-malformed",
            "receipt-unsupported"
        ]
    );
    assert!(service.messages().is_empty());
}

#[tokio::test]
async fn deletes_valid_messages_after_acknowledge_disposition() {
    let message = queue_message("event-1");
    let queue = TestQueue::with_receive_result(Ok(vec![valid_raw_message(
        &message.event.event_id,
        "receipt-1",
    )]));
    let service = TestDeliveryService::new([Ok(WebhookWorkerDisposition::Acknowledge)]);
    let worker = WebhookEventWorker::new(queue.clone(), service.clone());

    worker.poll_and_process_batch().await;

    assert_eq!(service.messages(), [message]);
    assert_eq!(queue.delete_requests(), ["receipt-1"]);
    assert!(queue.delay_requests().is_empty());
}

#[tokio::test]
async fn changes_visibility_after_retry_disposition() {
    let delay = Duration::from_secs(30);
    let queue = TestQueue::with_receive_result(Ok(vec![valid_raw_message("event-1", "receipt-1")]));
    let service = TestDeliveryService::new([Ok(WebhookWorkerDisposition::RetryAfter(delay))]);
    let worker = WebhookEventWorker::new(queue.clone(), service);

    worker.poll_and_process_batch().await;

    assert_eq!(queue.delay_requests(), [("receipt-1".to_string(), delay)]);
    assert!(queue.delete_requests().is_empty());
}

#[tokio::test]
async fn failed_acknowledgment_leaves_the_message_for_redelivery() {
    let queue = TestQueue::with_receive_result(Ok(vec![valid_raw_message("event-1", "receipt-1")]));
    queue.fail_delete("receipt-1");
    let service = TestDeliveryService::new([Ok(WebhookWorkerDisposition::Acknowledge)]);
    let worker = WebhookEventWorker::new(queue.clone(), service);

    worker.poll_and_process_batch().await;

    assert_eq!(queue.delete_requests(), ["receipt-1"]);
    assert!(queue.delay_requests().is_empty());
}

#[tokio::test]
async fn failed_visibility_update_leaves_the_message_for_redelivery() {
    let delay = Duration::from_secs(60);
    let queue = TestQueue::with_receive_result(Ok(vec![valid_raw_message("event-1", "receipt-1")]));
    queue.fail_delay("receipt-1");
    let service = TestDeliveryService::new([Ok(WebhookWorkerDisposition::RetryAfter(delay))]);
    let worker = WebhookEventWorker::new(queue.clone(), service);

    worker.poll_and_process_batch().await;

    assert_eq!(queue.delay_requests(), [("receipt-1".to_string(), delay)]);
    assert!(queue.delete_requests().is_empty());
}

#[tokio::test]
async fn service_failures_do_not_acknowledge_or_stop_the_batch() {
    let queue = TestQueue::with_receive_result(Ok(vec![
        valid_raw_message("event-1", "receipt-1"),
        valid_raw_message("event-2", "receipt-2"),
    ]));
    let service = TestDeliveryService::new([
        Err(TestError("service failed")),
        Ok(WebhookWorkerDisposition::Acknowledge),
    ]);
    let worker = WebhookEventWorker::new(queue.clone(), service.clone());

    worker.poll_and_process_batch().await;

    assert_eq!(
        service
            .messages()
            .into_iter()
            .map(|message| message.event.event_id)
            .collect::<Vec<_>>(),
        ["event-1", "event-2"]
    );
    assert_eq!(queue.delete_requests(), ["receipt-2"]);
    assert!(queue.delay_requests().is_empty());
}

#[tokio::test]
async fn processes_each_batch_sequentially() {
    let operations = Arc::new(Mutex::new(Vec::new()));
    let queue = TestQueue::with_receive_result(Ok(vec![
        valid_raw_message("event-1", "receipt-1"),
        valid_raw_message("event-2", "receipt-2"),
    ]));
    queue.set_operations(operations.clone());
    let service = TestDeliveryService::new([
        Ok(WebhookWorkerDisposition::Acknowledge),
        Ok(WebhookWorkerDisposition::Acknowledge),
    ]);
    service.set_operations(operations.clone());
    let worker = WebhookEventWorker::new(queue, service);

    worker.poll_and_process_batch().await;

    assert_eq!(
        *operations.lock().expect("operations lock"),
        [
            "service:event-1",
            "delete:receipt-1",
            "service:event-2",
            "delete:receipt-2",
        ]
    );
}