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.

9.4 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,
}

impl MockResponse {
    fn json(body: serde_json::Value) -> Self {
        Self {
            status: "200 OK",
            body: body.to_string(),
        }
    }
}

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

impl MockServer {
    fn start(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) -> 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>().unwrap())
            })
            .unwrap_or(0);
        if request.len() >= header_end + 4 + content_length {
            break;
        }
    }

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

#[tokio::test]
async fn exchanges_setup_code_for_access_token() {
    let server = MockServer::start(vec![MockResponse::json(serde_json::json!({
        "access_token": "returned-user-token",
        "token_type": "bearer",
        "scope": ""
    }))]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let token = client
        .exchange_setup_code("sync-client-id", "client-secret", "callback-code")
        .await
        .unwrap();

    assert_eq!(token.as_str(), "returned-user-token");
    let requests = server.finish();
    assert!(requests[0].starts_with("POST /login/oauth/access_token HTTP/1.1"));
    assert!(
        requests[0]
            .to_ascii_lowercase()
            .contains("accept: application/json")
    );
    assert!(requests[0].contains("\"client_id\":\"sync-client-id\""));
    assert!(requests[0].contains("\"client_secret\":\"client-secret\""));
    assert!(requests[0].contains("\"code\":\"callback-code\""));
}

#[tokio::test]
async fn rejects_unsuccessful_setup_code_exchange_without_leaking_secrets() {
    let server = MockServer::start(vec![MockResponse {
        status: "401 Unauthorized",
        body: "{\"error\":\"bad_verification_code\"}".to_string(),
    }]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .exchange_setup_code("sync-client-id", "very-secret", "sensitive-code")
        .await
        .err()
        .unwrap()
        .to_string();

    assert!(error.contains("401 Unauthorized"));
    assert!(!error.contains("very-secret"));
    assert!(!error.contains("sensitive-code"));
    server.finish();
}

#[tokio::test]
async fn finds_installation_on_a_later_page() {
    let first_page: Vec<_> = (1..=100)
        .map(|id| serde_json::json!({ "id": id }))
        .collect();
    let server = MockServer::start(vec![
        MockResponse::json(serde_json::json!({
            "total_count": 101,
            "installations": first_page
        })),
        MockResponse::json(serde_json::json!({
            "total_count": 101,
            "installations": [{ "id": 999 }]
        })),
    ]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let installations = client
        .list_user_installations("user-access-token")
        .await
        .unwrap();

    assert_eq!(installations.len(), 101);
    assert!(
        installations
            .iter()
            .any(|installation| installation.id == 999)
    );
    let requests = server.finish();
    assert!(requests[0].starts_with("GET /user/installations?per_page=100&page=1 HTTP/1.1"));
    assert!(requests[1].starts_with("GET /user/installations?per_page=100&page=2 HTTP/1.1"));
    for request in requests {
        let lowercase_request = request.to_ascii_lowercase();
        assert!(lowercase_request.contains("authorization: bearer user-access-token"));
        assert!(lowercase_request.contains("accept: application/vnd.github+json"));
        assert!(lowercase_request.contains("x-github-api-version: 2022-11-28"));
        assert!(lowercase_request.contains("user-agent: macro-auth-service"));
    }
}

#[tokio::test]
async fn rejects_unsuccessful_installation_list_without_leaking_token() {
    let server = MockServer::start(vec![MockResponse {
        status: "403 Forbidden",
        body: "{\"message\":\"forbidden\"}".to_string(),
    }]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .list_user_installations("sensitive-user-token")
        .await
        .unwrap_err()
        .to_string();

    assert!(error.contains("403 Forbidden"));
    assert!(!error.contains("sensitive-user-token"));
    server.finish();
}

#[tokio::test]
async fn rejects_malformed_later_pagination_response_without_leaking_token() {
    let server = MockServer::start(vec![
        MockResponse::json(serde_json::json!({
            "total_count": 2,
            "installations": [{ "id": 1 }]
        })),
        MockResponse {
            status: "200 OK",
            body: "not-json sensitive-user-token".to_string(),
        },
    ]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .list_user_installations("sensitive-user-token")
        .await
        .unwrap_err()
        .to_string();

    assert!(error.contains("malformed response"));
    assert!(!error.contains("sensitive-user-token"));
    assert_eq!(server.finish().len(), 2);
}

#[tokio::test]
async fn lists_repository_branches_across_pages_and_stops_on_a_short_page() {
    let first_page: Vec<_> = (1..=100)
        .map(|n| serde_json::json!({ "name": format!("branch-{n}") }))
        .collect();
    let server = MockServer::start(vec![
        MockResponse::json(serde_json::json!(first_page)),
        MockResponse::json(serde_json::json!([{ "name": "develop" }])),
    ]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let branches = client
        .list_repository_branches("ghs-scoped", "macro-inc", "macro")
        .await
        .unwrap();

    assert_eq!(branches.len(), 101);
    assert_eq!(branches[0], "branch-1");
    assert_eq!(branches[100], "develop");
    let requests = server.finish();
    assert!(
        requests[0].starts_with("GET /repos/macro-inc/macro/branches?per_page=100&page=1 HTTP/1.1")
    );
    assert!(
        requests[1].starts_with("GET /repos/macro-inc/macro/branches?per_page=100&page=2 HTTP/1.1")
    );
    for request in requests {
        let lowercase_request = request.to_ascii_lowercase();
        assert!(lowercase_request.contains("authorization: bearer ghs-scoped"));
        assert!(lowercase_request.contains("accept: application/vnd.github+json"));
    }
}

#[tokio::test]
async fn an_empty_repository_is_an_empty_branch_list() {
    let server = MockServer::start(vec![MockResponse {
        status: "404 Not Found",
        body: "{\"message\":\"Git Repository is empty.\"}".to_string(),
    }]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let branches = client
        .list_repository_branches("ghs-scoped", "macro-inc", "empty")
        .await
        .unwrap();

    assert!(branches.is_empty());
    server.finish();
}

#[tokio::test]
async fn rejects_an_unsuccessful_branch_list_without_leaking_the_token() {
    let server = MockServer::start(vec![MockResponse {
        status: "403 Forbidden",
        body: "{\"message\":\"forbidden\"}".to_string(),
    }]);
    let client = GithubSyncClientImpl::with_api_base_url(server.base_url.clone());

    let error = client
        .list_repository_branches("sensitive-install-token", "macro-inc", "macro")
        .await
        .unwrap_err()
        .to_string();

    assert!(error.contains("403 Forbidden"));
    assert!(!error.contains("sensitive-install-token"));
    server.finish();
}