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.8 KB
Raw Blame
use super::*;
use serde_json::json;
use wiremock::{
    Mock, MockServer, ResponseTemplate,
    matchers::{body_partial_json, method, path},
};

fn client(server: &MockServer) -> FusionAuthClient {
    FusionAuthClient::new(
        "api-key".into(),
        "application-id".into(),
        "client-secret".into(),
        server.uri(),
        "http://localhost/callback".into(),
        "google-client-id".into(),
        "google-client-secret".into(),
    )
}

fn grant(account: &str, token: &str) -> serde_json::Value {
    json!({
        "displayName": "octocat", "identityProviderId": "github",
        "identityProviderName": "GitHub", "identityProviderType": "GitHub",
        "identityProviderUserId": account, "insertInstant": 0,
        "lastLoginInstant": 0, "tenantId": "tenant", "token": token,
        "userId": uuid::Uuid::nil().to_string()
    })
}

#[tokio::test]
async fn refresh_replaces_the_matching_grant_and_restores_it_on_failure() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/identity-provider/link"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "identityProviderLinks": [grant("other", "other-token"), grant("1", "old-token")]
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("DELETE"))
        .and(wiremock::matchers::query_param(
            "identityProviderUserId",
            "1",
        ))
        .respond_with(ResponseTemplate::new(200))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(body_partial_json(json!({ "identityProviderLink": { "identityProviderUserId": "1", "token": "new-token" } })))
        .respond_with(ResponseTemplate::new(500)).expect(1).mount(&server).await;
    Mock::given(method("POST"))
        .and(body_partial_json(json!({ "identityProviderLink": { "identityProviderUserId": "1", "token": "old-token" } })))
        .respond_with(ResponseTemplate::new(200)).expect(1).mount(&server).await;

    let result = refresh_grant(
        &client(&server),
        &uuid::Uuid::nil(),
        "github",
        "1",
        "octocat",
        "new-token",
    )
    .await;

    assert!(result.is_err());
    let requests = server.received_requests().await.unwrap();
    assert_eq!(
        requests
            .iter()
            .map(|request| request.method.as_str())
            .collect::<Vec<_>>(),
        ["GET", "DELETE", "POST", "POST"]
    );
}

#[tokio::test]
async fn refresh_stores_fresh_token_and_identical_token_is_idempotent() {
    for old_token in ["old-token", "new-token"] {
        let server = MockServer::start().await;
        Mock::given(method("GET"))
            .respond_with(
                ResponseTemplate::new(200)
                    .set_body_json(json!({ "identityProviderLinks": [grant("1", old_token)] })),
            )
            .expect(1)
            .mount(&server)
            .await;
        let writes = u64::from(old_token != "new-token");
        Mock::given(method("DELETE"))
            .respond_with(ResponseTemplate::new(200))
            .expect(writes)
            .mount(&server)
            .await;
        Mock::given(method("POST"))
            .and(body_partial_json(
                json!({ "identityProviderLink": { "token": "new-token" } }),
            ))
            .respond_with(ResponseTemplate::new(200))
            .expect(writes)
            .mount(&server)
            .await;

        assert_eq!(
            refresh_grant(
                &client(&server),
                &uuid::Uuid::nil(),
                "github",
                "1",
                "octocat",
                "new-token"
            )
            .await
            .unwrap(),
            GithubGrantLinkOutcome::Linked
        );
    }
}

#[tokio::test]
async fn reconnect_recreates_a_grant_after_replacement_and_restoration_fail() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "identityProviderLinks": [grant("1", "old-token")]
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("DELETE"))
        .respond_with(ResponseTemplate::new(200))
        .expect(1)
        .mount(&server)
        .await;
    // Both the replacement and its best-effort restoration fail.
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(503))
        .expect(2)
        .mount(&server)
        .await;
    let client = client(&server);
    assert!(
        refresh_grant(
            &client,
            &uuid::Uuid::nil(),
            "github",
            "1",
            "octocat",
            "new-token"
        )
        .await
        .is_err()
    );
    server.verify().await;
    server.reset().await;

    // A crash after unlink leaves the same persistent state: an absent grant.
    // A subsequent verified OAuth attempt must recreate it without an unlink.
    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(404))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(body_partial_json(json!({
            "identityProviderLink": { "identityProviderUserId": "1", "token": "retry-token" }
        })))
        .respond_with(ResponseTemplate::new(200))
        .expect(1)
        .mount(&server)
        .await;
    assert_eq!(
        refresh_grant(
            &client,
            &uuid::Uuid::nil(),
            "github",
            "1",
            "octocat",
            "retry-token"
        )
        .await
        .unwrap(),
        GithubGrantLinkOutcome::Linked
    );
    let requests = server.received_requests().await.unwrap();
    assert_eq!(
        requests
            .iter()
            .map(|request| request.method.as_str())
            .collect::<Vec<_>>(),
        ["GET", "POST"]
    );
}

#[tokio::test]
async fn deleted_identity_is_reported_without_writes() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .respond_with(
            ResponseTemplate::new(400).set_body_json(
                json!({ "fieldErrors": { "userId": [{ "code": "[invalid]userId" }] } }),
            ),
        )
        .expect(1)
        .mount(&server)
        .await;

    assert_eq!(
        refresh_grant(
            &client(&server),
            &uuid::Uuid::nil(),
            "github",
            "1",
            "octocat",
            "new-token"
        )
        .await
        .unwrap(),
        GithubGrantLinkOutcome::IdentityMissing
    );
    assert_eq!(server.received_requests().await.unwrap().len(), 1);
}

#[tokio::test]
async fn delayed_lookup_cannot_overwrite_reconnected_token() {
    use std::sync::{
        Arc,
        atomic::{AtomicUsize, Ordering},
    };
    use tokio::sync::Notify;

    let url = std::env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1:6379".into());
    let mut conn = redis::Client::open(url)
        .unwrap()
        .get_multiplexed_async_connection()
        .await
        .expect("GitHub integration tests require local Redis or REDIS_URL; see docs/development/database.md");
    let identity = macro_uuid::generate_uuid_v7();
    // Legacy identity-only entries must not be used for another account.
    let legacy_key = format!("github_access_token_key:{identity}");
    conn.set_ex::<_, _, ()>(&legacy_key, "wrong-account-token", 60)
        .await
        .unwrap();
    let requests = Arc::new(AtomicUsize::new(0));
    let started = Arc::new(Notify::new());
    let release = Arc::new(Notify::new());
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let router = axum::Router::new().route("/api/identity-provider/link", axum::routing::get({
        let requests = requests.clone();
        let started = started.clone();
        let release = release.clone();
        move || {
            let requests = requests.clone();
            let started = started.clone();
            let release = release.clone();
            async move {
                let snapshot = json!({ "identityProviderLinks": [grant("other", "other-token"), grant("1", "old-token")] });
                if requests.fetch_add(1, Ordering::SeqCst) == 0 {
                    started.notify_one();
                    release.notified().await;
                }
                axum::Json(snapshot)
            }
        }
    }).delete(|| async { axum::http::StatusCode::OK }).post(|| async { axum::http::StatusCode::OK }));
    let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
    let fusionauth = FusionAuthClient::new(
        "api-key".into(),
        "application-id".into(),
        "client-secret".into(),
        format!("http://{address}"),
        "http://localhost/callback".into(),
        "google-client-id".into(),
        "google-client-secret".into(),
    );
    let adapter = GithubAuthImpl::new(fusionauth, conn.clone());
    let lookup = tokio::spawn({
        let adapter = adapter.clone();
        async move {
            adapter
                .retreive_access_token(&identity, "github", "1")
                .await
                .unwrap()
                .unwrap()
        }
    });
    started.notified().await;
    assert_eq!(
        adapter
            .link_user(&identity, "github", "1", "octocat", "new-token")
            .await
            .unwrap(),
        GithubGrantLinkOutcome::Linked
    );
    release.notify_one();

    assert_eq!(lookup.await.unwrap().as_str(), "new-token");
    assert_eq!(
        adapter
            .retreive_access_token(&identity, "github", "1")
            .await
            .unwrap()
            .unwrap()
            .as_str(),
        "new-token"
    );
    assert_eq!(requests.load(Ordering::SeqCst), 2);
    conn.del::<_, ()>(&[legacy_key, github_access_token_key!(identity, "1")])
        .await
        .unwrap();
    server.abort();
}