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.

6.8 KB
Raw Blame
use super::*;
use crate::outbound::test_support::mock_http;
use aws_sdk_sqs::config::{BehaviorVersion, Credentials, Region, retry::RetryConfig};
use serde_json::{Value, json};

fn event(generation: u64) -> ImportEvent {
    ImportEvent {
        job_id: "01980000-0000-7000-8000-000000000001".parse().unwrap(),
        slack_channel_id: "C123".parse().unwrap(),
        generation,
    }
}

fn response(body: Value) -> String {
    let body = body.to_string();
    format!(
        "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: application/x-amz-json-1.0\r\nContent-Length: {}\r\n\r\n{body}",
        body.len()
    )
}

fn client(endpoint: &str) -> Client {
    Client::from_conf(
        aws_sdk_sqs::Config::builder()
            .behavior_version(BehaviorVersion::latest())
            .region(Region::new("us-east-1"))
            .credentials_provider(Credentials::new("test", "test", None, None, "test"))
            .endpoint_url(endpoint)
            .retry_config(RetryConfig::disabled())
            .build(),
    )
}

async fn queue(endpoint: &str) -> SqsImportQueue {
    SqsImportQueue::new(
        client(endpoint),
        &SlackImportQueue::from_owned(format!("{endpoint}/main")),
        &SlackImportDlq::from_owned(format!("{endpoint}/dlq")),
    )
    .await
    .unwrap()
}

fn request_body(request: &str) -> Value {
    serde_json::from_str(request.split_once("\r\n\r\n").unwrap().1).unwrap()
}

#[tokio::test]
async fn resolves_typed_names_at_startup() {
    let (endpoint, requests) = mock_http(vec![
        response(json!({"QueueUrl":"https://queue/main"})),
        response(json!({"QueueUrl":"https://queue/dlq"})),
    ]);
    let queue = SqsImportQueue::new(
        client(&endpoint),
        &SlackImportQueue::dev(),
        &SlackImportDlq::dev(),
    )
    .await
    .unwrap();
    assert_eq!(queue.main_url, "https://queue/main");
    assert_eq!(queue.dlq_url, "https://queue/dlq");
    assert_eq!(
        request_body(&requests.recv().unwrap())["QueueName"],
        "slack-import-queue-dev"
    );
    assert_eq!(
        request_body(&requests.recv().unwrap())["QueueName"],
        "slack-import-dlq-dev"
    );
}

#[tokio::test]
async fn partial_batch_success_only_acknowledges_accepted_events() {
    let (endpoint, requests) = mock_http(vec![response(json!({
        "Successful": [{"Id":"1", "MessageId":"m1", "MD5OfMessageBody":"unused"}],
        "Failed": [{"Id":"0", "Code":"ServiceUnavailable", "SenderFault":false}]
    }))]);
    let events = [event(1), event(2)];
    let result = queue(&endpoint).await.publish_batch(&events).await.unwrap();
    assert_eq!(result.published, vec![event(2)]);
    assert_eq!(result.failed.len(), 1);
    assert_eq!(result.failed[0].event, event(1));
    assert!(!result.failed[0].sender_fault);
    let body = request_body(&requests.recv().unwrap());
    assert_eq!(body["Entries"][0]["Id"], "0");
    let payload: Value =
        serde_json::from_str(body["Entries"][0]["MessageBody"].as_str().unwrap()).unwrap();
    assert_eq!(payload.as_object().unwrap().len(), 3);
    assert_eq!(payload, serde_json::to_value(event(1)).unwrap());
}

#[tokio::test]
async fn publication_rejects_failed_missing_duplicate_and_unknown_results() {
    for body in [
        json!({"Successful":[], "Failed":[{"Id":"0", "Code":"Invalid", "SenderFault":true}]}),
        json!({"Successful":[], "Failed":[]}),
        json!({"Successful":[{"Id":"9", "MessageId":"m", "MD5OfMessageBody":"x"}], "Failed":[]}),
        json!({"Successful":[{"Id":"0", "MessageId":"m", "MD5OfMessageBody":"x"}], "Failed":[{"Id":"0", "Code":"Invalid", "SenderFault":false}]}),
    ] {
        let (endpoint, _) = mock_http(vec![response(body)]);
        assert!(queue(&endpoint).await.publish(&event(1)).await.is_err());
    }
    let queue = queue("http://127.0.0.1:1").await;
    assert!(queue.publish_batch(&[]).await.is_err());
    assert!(queue.publish_batch(&vec![event(1); 11]).await.is_err());
}

#[tokio::test]
async fn long_poll_counts_visibility_and_ack_use_delivery_origin_including_dlq() {
    for source in [QueueSource::Main, QueueSource::DeadLetter] {
        let body = json!({"Messages": [
            {"MessageId":"m", "ReceiptHandle":"receipt", "Body":serde_json::to_string(&event(1)).unwrap(), "Attributes":{"ApproximateReceiveCount":"5"}},
            {"MessageId":"bad", "ReceiptHandle":"bad-receipt", "Body":"{\"key\":\"untrusted\"}", "Attributes":{"ApproximateReceiveCount":"1"}}
        ]});
        let (endpoint, requests) = mock_http(vec![
            response(body),
            response(json!({})),
            response(json!({})),
        ]);
        let queue = queue(&endpoint).await;
        let deliveries = queue.receive(source).await.unwrap();
        assert_eq!(deliveries.len(), 2);
        assert_eq!(deliveries[0].receive_count, 5);
        assert_eq!(deliveries[0].event, Ok(event(1)));
        assert_eq!(deliveries[1].event, Err(ImportError::InvalidInput));
        assert!(
            queue
                .extend_visibility(&deliveries[0], 43_201)
                .await
                .is_err()
        );
        queue.extend_visibility(&deliveries[0], 180).await.unwrap();
        queue.delete(&deliveries[0]).await.unwrap();
        let poll = request_body(&requests.recv().unwrap());
        assert_eq!(poll["WaitTimeSeconds"], 20);
        assert_eq!(poll["MaxNumberOfMessages"], 10);
        assert_eq!(poll["VisibilityTimeout"], 180);
        assert_eq!(
            poll["MessageSystemAttributeNames"],
            json!(["ApproximateReceiveCount"])
        );
        assert_eq!(poll["QueueUrl"], queue.url(source));
        let visibility = request_body(&requests.recv().unwrap());
        assert_eq!(visibility["QueueUrl"], queue.url(source));
        assert_eq!(visibility["VisibilityTimeout"], 180);
        assert_eq!(visibility["ReceiptHandle"], "receipt");
        let delete = request_body(&requests.recv().unwrap());
        assert_eq!(delete["QueueUrl"], queue.url(source));
        assert_eq!(delete["ReceiptHandle"], "receipt");
    }
}

#[tokio::test]
async fn driver_polls_one_delivery_per_available_slot() {
    let (endpoint, requests) = mock_http(vec![response(json!({"Messages": []}))]);
    assert!(
        ImportConsumer::receive(&queue(&endpoint).await, false)
            .await
            .unwrap()
            .is_none()
    );
    let poll = request_body(&requests.recv().unwrap());
    assert_eq!(poll["MaxNumberOfMessages"], 1);
    assert_eq!(poll["VisibilityTimeout"], 180);
}

#[test]
fn missing_receipt_or_receive_count_never_becomes_an_acknowledgeable_delivery() {
    assert!(delivery(QueueSource::Main, Message::builder().body("{}").build()).is_err());
    assert!(
        delivery(
            QueueSource::Main,
            Message::builder()
                .receipt_handle("receipt")
                .body("{}")
                .build()
        )
        .is_err()
    );
}