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.

7.0 KB
Raw Blame
use super::*;
use crate::{ISSUER, decode, encode};
use jsonwebtoken::errors::ErrorKind;
use serde::{Deserialize, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};

const ID: &str = "0194c5d8-8f00-7000-8000-abcdef012345";
const SECRET: &str = "session-tests-only";

fn now() -> usize {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs() as usize
}

fn claims() -> SurfaceClaims {
    SurfaceClaims {
        session_kind: SurfaceSessionKind::Surface,
        surface_id: ID.parse().unwrap(),
        user_id: Some("macro|[email protected]".into()),
        access_level: SurfaceAccessLevel::Edit,
        actor: None,
        exp: now() + crate::TOKEN_TTL_SECS,
        iss: ISSUER.into(),
    }
}

// Mirrors the existing document issuer and consumer without backend dependencies.
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
struct LegacyDocumentClaims {
    user_id: Option<String>,
    document_id: String,
    access_level: SurfaceAccessLevel,
    exp: usize,
    iss: String,
}

#[derive(Serialize)]
struct RawSurfaceClaims<'a> {
    #[serde(skip_serializing_if = "Option::is_none")]
    session_kind: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    surface_id: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    document_id: Option<&'a str>,
    access_level: &'a str,
    exp: usize,
    iss: &'a str,
}

fn raw_claims() -> RawSurfaceClaims<'static> {
    RawSurfaceClaims {
        session_kind: Some("surface"),
        surface_id: Some(ID),
        document_id: None,
        access_level: "edit",
        exp: now() + crate::TOKEN_TTL_SECS,
        iss: ISSUER,
    }
}

fn rejects(raw: &RawSurfaceClaims<'_>) {
    let token = encode(raw, SECRET).unwrap();
    assert!(decode_surface(token.as_str(), SECRET).is_err());
}

#[test]
fn identical_uuids_have_distinct_targets_and_storage_keys() {
    let document = SessionIdentity::new(SessionKind::Document, ID).unwrap();
    let surface = SessionIdentity::new(SessionKind::Surface, ID).unwrap();
    assert_ne!(document, surface);
    assert_eq!(document.kind(), SessionKind::Document);
    assert_eq!(surface.kind(), SessionKind::Surface);
    assert_eq!(document.id(), surface.id());
    assert_eq!(document.storage_key(), ID);
    assert_eq!(surface.storage_key(), format!("surface:{ID}"));
}

#[test]
fn surface_keys_are_canonical_but_document_names_are_unchanged() {
    let uppercase = ID.to_ascii_uppercase();
    let surface = SessionIdentity::new(SessionKind::Surface, &uppercase).unwrap();
    assert_eq!(surface.id(), ID);
    assert_eq!(surface.storage_key(), format!("surface:{ID}"));
    let document = SessionIdentity::new(SessionKind::Document, &uppercase).unwrap();
    assert_eq!(document.id(), uppercase);
    assert_eq!(document.storage_key(), uppercase);
    let id: SurfaceId = uppercase.parse().unwrap();
    assert_eq!(id.as_str(), ID);
    assert_eq!(id.to_string(), ID);
}

#[test]
fn malformed_ids_cannot_enter_identities_or_claims() {
    for id in [
        "",
        "not-a-uuid",
        "0194c5d88f0070008000abcdef012345",
        "0194c5d8-8f00-7000-8000-abcdef01234g",
        "0194c5d8_8f00-7000-8000-abcdef012345",
        "0194c5d8-8f00-7000-8000-abcdef012345/ops",
        "surface:0194c5d8-8f00-7000-8000-abcdef012345",
        "{0194c5d8-8f00-7000-8000-abcdef012345}",
        " 0194c5d8-8f00-7000-8000-abcdef012345",
        "0194c5d8-8f00-7000-8000-abcdef01234é",
    ] {
        assert!(id.parse::<SurfaceId>().is_err(), "{id}");
        for kind in [SessionKind::Document, SessionKind::Surface] {
            assert!(SessionIdentity::new(kind, id).is_err(), "{id}");
        }
        let mut raw = raw_claims();
        raw.surface_id = Some(id);
        rejects(&raw);
    }
}

#[test]
fn surface_token_round_trip_has_explicit_kind_and_scoped_id() {
    let expected = claims();
    let token = encode_surface(&expected, SECRET).unwrap();
    let actual = decode_surface(token.as_str(), SECRET).unwrap();
    assert_eq!(actual, expected);
    assert_eq!(
        actual.session_identity(),
        SessionIdentity::new(SessionKind::Surface, ID).unwrap()
    );

    #[derive(Deserialize)]
    struct WireClaims {
        session_kind: SessionKind,
        surface_id: String,
    }
    let wire: WireClaims = decode(token.as_str(), SECRET).unwrap();
    assert_eq!(wire.session_kind, SessionKind::Surface);
    assert_eq!(wire.surface_id, ID);
    assert!(decode::<LegacyDocumentClaims>(token.as_str(), SECRET).is_err());
}

#[test]
fn legacy_document_tokens_remain_compatible_but_are_not_surface_grants() {
    let expected = LegacyDocumentClaims {
        user_id: None,
        document_id: ID.into(),
        access_level: SurfaceAccessLevel::Comment,
        exp: now() + crate::TOKEN_TTL_SECS,
        iss: ISSUER.into(),
    };
    let token = encode(&expected, SECRET).unwrap();
    assert_eq!(
        decode::<LegacyDocumentClaims>(token.as_str(), SECRET).unwrap(),
        expected
    );
    assert!(decode_surface(token.as_str(), SECRET).is_err());
}

#[test]
fn surface_claims_require_surface_kind_and_surface_id() {
    for kind in [None, Some("document"), Some("initiative"), Some("Surface")] {
        let mut raw = raw_claims();
        raw.session_kind = kind;
        rejects(&raw);
    }
    let mut raw = raw_claims();
    raw.surface_id = None;
    rejects(&raw);
    raw.document_id = Some(ID);
    rejects(&raw);
    raw.surface_id = Some(ID);
    rejects(&raw); // Reject ambiguous grants containing both target fields.
}

#[test]
fn unsupported_access_levels_are_rejected() {
    for level in ["admin", "write", "Edit", ""] {
        let mut raw = raw_claims();
        raw.access_level = level;
        rejects(&raw);
    }
    for level in ["view", "comment", "edit", "owner"] {
        let mut raw = raw_claims();
        raw.access_level = level;
        let token = encode(&raw, SECRET).unwrap();
        assert!(decode_surface(token.as_str(), SECRET).is_ok());
    }
}

#[test]
fn expired_surface_tokens_are_rejected_without_default_clock_leeway() {
    let mut expired = claims();
    expired.exp = now() - 1;
    let token = encode_surface(&expired, SECRET).unwrap();
    assert_eq!(
        decode_surface(token.as_str(), SECRET).unwrap_err().kind(),
        &ErrorKind::ExpiredSignature
    );
}

#[test]
fn surface_tokens_require_expected_issuer_and_signature() {
    let valid = claims();
    let token = encode_surface(&valid, SECRET).unwrap();
    assert!(decode_surface(token.as_str(), "wrong-secret").is_err());
    let mut raw = raw_claims();
    raw.iss = "another-service";
    rejects(&raw);
}

#[test]
fn surface_tokens_require_expiry() {
    #[derive(Serialize)]
    struct NoExpiry {
        session_kind: SessionKind,
        surface_id: SurfaceId,
        access_level: SurfaceAccessLevel,
        iss: &'static str,
    }
    let token = encode(
        &NoExpiry {
            session_kind: SessionKind::Surface,
            surface_id: ID.parse().unwrap(),
            access_level: SurfaceAccessLevel::View,
            iss: ISSUER,
        },
        SECRET,
    )
    .unwrap();
    assert!(decode_surface(token.as_str(), SECRET).is_err());
}