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.

23.3 KB
Raw Blame
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::mpsc::{self, Receiver};
use std::thread::JoinHandle;
use std::time::Duration;

use super::*;

struct MockResponse {
    status: &'static str,
    body: String,
}

struct MockServer {
    base_url: String,
    requests: Receiver<String>,
    handle: JoinHandle<()>,
}

impl MockServer {
    fn start(response: MockResponse) -> Self {
        Self::start_many(vec![response])
    }

    /// Answers one connection per response, in order.
    fn start_many(responses: Vec<MockResponse>) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
        let base_url = format!("http://{}", listener.local_addr().unwrap());
        let (request_sender, requests) = mpsc::channel();
        let handle = std::thread::spawn(move || {
            for response in responses {
                let (mut stream, _) = listener.accept().unwrap();
                let request = read_request(&mut stream);
                request_sender.send(request).unwrap();
                write!(
                    stream,
                    "HTTP/1.1 {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
                    response.status,
                    response.body.len(),
                    response.body
                )
                .unwrap();
            }
        });

        Self {
            base_url,
            requests,
            handle,
        }
    }

    fn finish(self) -> String {
        self.finish_all().remove(0)
    }

    fn finish_all(self) -> Vec<String> {
        self.handle.join().unwrap();
        self.requests.try_iter().collect()
    }
}

fn read_request(stream: &mut TcpStream) -> String {
    stream
        .set_read_timeout(Some(Duration::from_secs(5)))
        .unwrap();
    let mut request = Vec::new();
    let mut buffer = [0_u8; 4096];

    loop {
        let bytes_read = stream.read(&mut buffer).unwrap();
        if bytes_read == 0 {
            break;
        }
        request.extend_from_slice(&buffer[..bytes_read]);

        let Some(header_end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") else {
            continue;
        };
        let headers = String::from_utf8_lossy(&request[..header_end]);
        let content_length = headers
            .lines()
            .find_map(|line| {
                let (name, value) = line.split_once(':')?;
                name.eq_ignore_ascii_case("content-length")
                    .then(|| value.trim().parse::<usize>().ok())
                    .flatten()
            })
            .unwrap_or(0);
        if request.len() >= header_end + 4 + content_length {
            break;
        }
    }

    String::from_utf8(request).unwrap()
}

#[tokio::test]
async fn merge_pull_request_sends_method_and_reports_merge() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({
            "sha": "6dcb09b5b57875f334f61aebed695e2e4193db5e",
            "merged": true,
            "message": "Pull Request successfully merged"
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Squash)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubMergeOutcome::Merged(GithubPullRequestMerge {
            sha: "6dcb09b5b57875f334f61aebed695e2e4193db5e".to_string(),
            message: "Pull Request successfully merged".to_string(),
        })
    );
    let request = server.finish();
    assert!(request.starts_with("PUT /repos/macro/app/pulls/7/merge HTTP/1.1"));
    assert!(
        request
            .to_ascii_lowercase()
            .contains("authorization: bearer token")
    );
    assert!(request.ends_with(r#"{"merge_method":"squash"}"#));
}

#[tokio::test]
async fn merge_pull_request_reports_not_mergeable_with_github_message() {
    let server = MockServer::start(MockResponse {
        status: "405 Method Not Allowed",
        body: serde_json::json!({
            "message": "Required status check \"ci\" is expected.",
            "documentation_url": "https://docs.github.com"
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Merge)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubMergeOutcome::Rejected {
            rejection: GithubMergeRejection::NotMergeable,
            message: "Required status check \"ci\" is expected.".to_string(),
        }
    );
    server.finish();
}

#[tokio::test]
async fn merge_pull_request_maps_head_change_and_access_statuses() {
    for (status, expected) in [
        ("409 Conflict", GithubMergeRejection::HeadChanged),
        ("404 Not Found", GithubMergeRejection::NotFound),
        ("403 Forbidden", GithubMergeRejection::Forbidden),
        ("422 Unprocessable Entity", GithubMergeRejection::Invalid),
    ] {
        let server = MockServer::start(MockResponse {
            status,
            body: serde_json::json!({ "message": "declined" }).to_string(),
        });
        let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

        let outcome = client
            .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Merge)
            .await
            .unwrap();

        assert_eq!(
            outcome,
            GithubMergeOutcome::Rejected {
                rejection: expected,
                message: "declined".to_string(),
            },
            "status {status}"
        );
        server.finish();
    }
}

#[tokio::test]
async fn merge_pull_request_treats_a_failing_github_as_unavailable() {
    let server = MockServer::start(MockResponse {
        status: "502 Bad Gateway",
        body: "upstream down".to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Merge)
        .await
        .unwrap_err();

    assert_eq!(upstream_failure(error), Some(UpstreamFailure::Unavailable));
    server.finish();
}

fn upstream_failure(error: GithubError) -> Option<UpstreamFailure> {
    match error {
        GithubError::Upstream(UpstreamError { service, failure }) => {
            assert_eq!(service, "GitHub");
            Some(failure)
        }
        _ => None,
    }
}

async fn github_answering(response: wiremock::ResponseTemplate) -> wiremock::MockServer {
    let server = wiremock::MockServer::start().await;
    wiremock::Mock::given(wiremock::matchers::any())
        .respond_with(response)
        .mount(&server)
        .await;
    server
}

#[tokio::test]
async fn token_check_reports_an_expired_token() {
    let server = github_answering(wiremock::ResponseTemplate::new(401)).await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    assert!(client.is_access_token_expired("token").await.unwrap());
}

#[tokio::test]
async fn token_check_treats_an_exhausted_rate_limit_as_throttling() {
    let reset = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs()
        + 120;
    let server = github_answering(
        wiremock::ResponseTemplate::new(403)
            .insert_header("x-ratelimit-remaining", "0")
            .insert_header("x-ratelimit-reset", reset.to_string().as_str())
            .set_body_string(r#"{"message":"API rate limit exceeded"}"#),
    )
    .await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client.is_access_token_expired("token").await.unwrap_err();

    let Some(UpstreamFailure::RateLimited {
        retry_after: Some(retry_after),
    }) = upstream_failure(error)
    else {
        panic!("expected a rate limit with a delay");
    };
    assert!(
        (110..=120).contains(&retry_after.as_secs()),
        "{retry_after:?}"
    );
}

#[tokio::test]
async fn token_check_treats_a_secondary_rate_limit_as_throttling() {
    let server =
        github_answering(wiremock::ResponseTemplate::new(403).insert_header("retry-after", "30"))
            .await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client.is_access_token_expired("token").await.unwrap_err();

    assert_eq!(
        upstream_failure(error),
        Some(UpstreamFailure::RateLimited {
            retry_after: Some(Duration::from_secs(30)),
        })
    );
}

#[tokio::test]
async fn a_secondary_rate_limit_without_headers_is_throttling() {
    // Primary quota left; its reset is an hour away and says nothing about
    // when the secondary limit lifts.
    let reset = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs()
        + 3600;
    let secondary = || {
        wiremock::ResponseTemplate::new(403)
            .insert_header("x-ratelimit-remaining", "4999")
            .insert_header("x-ratelimit-reset", reset.to_string().as_str())
            .set_body_string(
                r#"{"message":"You have exceeded a secondary rate limit. Please wait a few minutes before you try again."}"#,
            )
    };
    let throttled = Some(UpstreamFailure::RateLimited { retry_after: None });

    let server = github_answering(secondary()).await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());
    let error = client.is_access_token_expired("token").await.unwrap_err();
    assert_eq!(upstream_failure(error), throttled);

    let error = client
        .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Merge)
        .await
        .unwrap_err();
    assert_eq!(upstream_failure(error), throttled);
}

#[tokio::test]
async fn token_check_treats_a_failing_github_as_unavailable() {
    let server = github_answering(wiremock::ResponseTemplate::new(503)).await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client.is_access_token_expired("token").await.unwrap_err();

    assert_eq!(upstream_failure(error), Some(UpstreamFailure::Unavailable));
}

#[tokio::test]
async fn token_check_treats_an_unreachable_github_as_unavailable() {
    let address = TcpListener::bind("127.0.0.1:0")
        .unwrap()
        .local_addr()
        .unwrap();
    let client = GithubOauthImpl::with_api_base_url(format!("http://{address}"));

    let error = client.is_access_token_expired("token").await.unwrap_err();

    assert_eq!(upstream_failure(error), Some(UpstreamFailure::Unavailable));
}

#[tokio::test]
async fn token_check_keeps_a_plain_refusal_ours() {
    let server = github_answering(
        wiremock::ResponseTemplate::new(403).set_body_string(r#"{"message":"Forbidden"}"#),
    )
    .await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client.is_access_token_expired("token").await.unwrap_err();

    assert!(matches!(error, GithubError::Internal(_)));
}

#[tokio::test]
async fn merge_pull_request_does_not_read_a_rate_limit_as_a_refusal() {
    let server = github_answering(
        wiremock::ResponseTemplate::new(403)
            .insert_header("x-ratelimit-remaining", "0")
            .set_body_string(r#"{"message":"API rate limit exceeded"}"#),
    )
    .await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client
        .merge_pull_request("token", "macro", "app", 7, GithubMergeMethod::Merge)
        .await
        .unwrap_err();

    assert_eq!(
        upstream_failure(error),
        Some(UpstreamFailure::RateLimited { retry_after: None })
    );
}

#[tokio::test]
async fn get_repository_merge_settings_reads_allowed_methods() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({
            "full_name": "macro/app",
            "allow_merge_commit": false,
            "allow_squash_merge": true,
            "allow_rebase_merge": false
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let settings = client
        .get_repository_merge_settings("token", "macro", "app")
        .await
        .unwrap();

    assert_eq!(
        settings,
        GithubRepositoryMergeSettings {
            allow_merge_commit: false,
            allow_squash_merge: true,
            allow_rebase_merge: false,
        }
    );
    assert_eq!(settings.default_method(), Some(GithubMergeMethod::Squash));
    let request = server.finish();
    assert!(request.starts_with("GET /repos/macro/app HTTP/1.1"));
}

#[tokio::test]
async fn get_repository_merge_settings_defaults_missing_fields_to_allowed() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({ "full_name": "macro/app" }).to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let settings = client
        .get_repository_merge_settings("token", "macro", "app")
        .await
        .unwrap();

    assert_eq!(settings.default_method(), Some(GithubMergeMethod::Merge));
    server.finish();
}

fn graphql_body(request: &str) -> serde_json::Value {
    let body = request.split("\r\n\r\n").nth(1).unwrap();
    serde_json::from_str(body).unwrap()
}

#[tokio::test]
async fn set_pull_request_draft_converts_an_open_pull_request() {
    let server = MockServer::start_many(vec![
        MockResponse {
            status: "200 OK",
            body: serde_json::json!({
                "data": { "repository": { "pullRequest": { "id": "PR_node", "isDraft": false } } }
            })
            .to_string(),
        },
        MockResponse {
            status: "200 OK",
            body: serde_json::json!({
                "data": { "convertPullRequestToDraft": { "pullRequest": { "isDraft": true } } }
            })
            .to_string(),
        },
    ]);
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_draft("token", "macro", "app", 7, true)
        .await
        .unwrap();

    assert_eq!(outcome, GithubDraftOutcome::Changed { draft: true });
    let requests = server.finish_all();
    assert_eq!(requests.len(), 2);
    assert!(requests[0].starts_with("POST /graphql HTTP/1.1"));
    let lookup = graphql_body(&requests[0]);
    assert_eq!(
        lookup["variables"],
        serde_json::json!({ "owner": "macro", "repo": "app", "number": 7 })
    );
    let mutation = graphql_body(&requests[1]);
    assert!(
        mutation["query"]
            .as_str()
            .unwrap()
            .contains("convertPullRequestToDraft")
    );
    assert_eq!(
        mutation["variables"],
        serde_json::json!({ "id": "PR_node" })
    );
}

#[tokio::test]
async fn set_pull_request_draft_skips_the_mutation_when_already_in_state() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({
            "data": { "repository": { "pullRequest": { "id": "PR_node", "isDraft": false } } }
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_draft("token", "macro", "app", 7, false)
        .await
        .unwrap();

    assert_eq!(outcome, GithubDraftOutcome::Changed { draft: false });
    assert_eq!(server.finish_all().len(), 1);
}

#[tokio::test]
async fn set_pull_request_draft_reports_graphql_refusals() {
    let server = MockServer::start_many(vec![
        MockResponse {
            status: "200 OK",
            body: serde_json::json!({
                "data": { "repository": { "pullRequest": { "id": "PR_node", "isDraft": true } } }
            })
            .to_string(),
        },
        MockResponse {
            status: "200 OK",
            body: serde_json::json!({
                "data": { "markPullRequestReadyForReview": null },
                "errors": [{ "type": "FORBIDDEN", "message": "Resource not accessible" }]
            })
            .to_string(),
        },
    ]);
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_draft("token", "macro", "app", 7, false)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubDraftOutcome::Rejected {
            rejection: GithubPullRequestUpdateRejection::Forbidden,
            message: "Resource not accessible".to_string(),
        }
    );
    let requests = server.finish_all();
    assert!(
        graphql_body(&requests[1])["query"]
            .as_str()
            .unwrap()
            .contains("markPullRequestReadyForReview")
    );
}

#[tokio::test]
async fn set_pull_request_draft_reports_a_missing_pull_request() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({
            "data": { "repository": null },
            "errors": [{ "type": "NOT_FOUND", "message": "Could not resolve to a Repository" }]
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_draft("token", "macro", "app", 7, true)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubDraftOutcome::Rejected {
            rejection: GithubPullRequestUpdateRejection::NotFound,
            message: "Could not resolve to a Repository".to_string(),
        }
    );
    server.finish();
}

#[tokio::test]
async fn set_pull_request_state_sends_the_state_and_reports_githubs_answer() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({ "number": 7, "state": "closed", "merged": false }).to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_state("token", "macro", "app", 7, GithubPullRequestState::Closed)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubStateOutcome::Changed {
            state: GithubPullRequestState::Closed,
        }
    );
    let request = server.finish();
    assert!(request.starts_with("PATCH /repos/macro/app/pulls/7 HTTP/1.1"));
    assert!(
        request
            .to_ascii_lowercase()
            .contains("authorization: bearer token")
    );
    assert!(request.ends_with(r#"{"state":"closed"}"#));
}

#[tokio::test]
async fn set_pull_request_state_maps_access_and_validation_statuses() {
    for (status, expected) in [
        ("403 Forbidden", GithubPullRequestUpdateRejection::Forbidden),
        ("404 Not Found", GithubPullRequestUpdateRejection::NotFound),
        (
            "422 Unprocessable Entity",
            GithubPullRequestUpdateRejection::Invalid,
        ),
    ] {
        let server = MockServer::start(MockResponse {
            status,
            body: serde_json::json!({ "message": "declined" }).to_string(),
        });
        let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

        let outcome = client
            .set_pull_request_state("token", "macro", "app", 7, GithubPullRequestState::Open)
            .await
            .unwrap();

        assert_eq!(
            outcome,
            GithubStateOutcome::Rejected {
                rejection: expected,
                message: "declined".to_string(),
            },
            "status {status}"
        );
        let request = server.finish();
        assert!(request.ends_with(r#"{"state":"open"}"#));
    }
}

#[tokio::test]
async fn set_pull_request_state_reports_the_validation_reason() {
    let server = MockServer::start(MockResponse {
        status: "422 Unprocessable Entity",
        body: serde_json::json!({
            "message": "Validation Failed",
            "errors": [{
                "resource": "PullRequest",
                "code": "custom",
                "message": "state cannot be changed. The head branch was deleted."
            }]
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let outcome = client
        .set_pull_request_state("token", "macro", "app", 7, GithubPullRequestState::Open)
        .await
        .unwrap();

    assert_eq!(
        outcome,
        GithubStateOutcome::Rejected {
            rejection: GithubPullRequestUpdateRejection::Invalid,
            message: "state cannot be changed. The head branch was deleted.".to_string(),
        }
    );
    server.finish();
}

#[tokio::test]
async fn set_pull_request_state_reports_a_failing_github_as_unavailable() {
    let server = MockServer::start(MockResponse {
        status: "502 Bad Gateway",
        body: "upstream down".to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .set_pull_request_state("token", "macro", "app", 7, GithubPullRequestState::Closed)
        .await
        .unwrap_err();

    assert_eq!(upstream_failure(error), Some(UpstreamFailure::Unavailable));
    server.finish();
}

#[tokio::test]
async fn set_pull_request_state_does_not_read_a_rate_limit_as_a_refusal() {
    let server = github_answering(
        wiremock::ResponseTemplate::new(403)
            .insert_header("x-ratelimit-remaining", "0")
            .set_body_string(r#"{"message":"API rate limit exceeded"}"#),
    )
    .await;
    let client = GithubOauthImpl::with_api_base_url(server.uri());

    let error = client
        .set_pull_request_state("token", "macro", "app", 7, GithubPullRequestState::Closed)
        .await
        .unwrap_err();

    assert_eq!(
        upstream_failure(error),
        Some(UpstreamFailure::RateLimited { retry_after: None })
    );
}

#[tokio::test]
async fn get_pull_request_mergeability_batches_and_skips_hidden_pull_requests() {
    let server = MockServer::start(MockResponse {
        status: "200 OK",
        body: serde_json::json!({
            "data": {
                "p0": { "pullRequest": { "mergeable": "CONFLICTING" } },
                "p1": null,
                "p2": { "pullRequest": { "mergeable": "UNKNOWN" } }
            },
            "errors": [{ "type": "NOT_FOUND", "message": "Could not resolve to a Repository" }]
        })
        .to_string(),
    });
    let client = GithubOauthImpl::with_api_base_url(server.base_url.clone());
    let number = |repo: &str, number| GithubPullRequestNumber {
        owner: "macro".to_string(),
        repo: repo.to_string(),
        number,
    };

    let entries = client
        .get_pull_request_mergeability(
            "token",
            &[number("app", 7), number("secret", 1), number("app", 9)],
        )
        .await
        .unwrap();

    assert_eq!(
        entries,
        vec![
            GithubPullRequestMergeabilityEntry {
                owner: "macro".to_string(),
                repo: "app".to_string(),
                number: 7,
                mergeability: GithubPullRequestMergeability::Conflicting,
            },
            GithubPullRequestMergeabilityEntry {
                owner: "macro".to_string(),
                repo: "app".to_string(),
                number: 9,
                mergeability: GithubPullRequestMergeability::Unknown,
            },
        ]
    );
    let body = graphql_body(&server.finish());
    assert_eq!(body["variables"]["r1"], "secret");
    assert_eq!(body["variables"]["n2"], 9);
    assert!(body["query"].as_str().unwrap().contains("p2: repository"));
}