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.

10.1 KB
Raw Blame
use super::*;
use crate::local::{inventory, repo_root};

#[test]
fn vite_routes_cover_every_backend_prefix_and_no_frontend_routes() {
    let prefixes = frontend_path_prefixes();
    for svc in inventory::RUST_SERVICES {
        if let Some(prefix) = svc.path_prefix {
            assert!(prefixes.contains(&prefix));
        }
    }
    for prefix in [
        "/websocket",
        "/sync",
        "/i",
        "/lexical",
        "/ai-editing",
        "/static-file",
        "/local-storage",
    ] {
        assert!(prefixes.contains(&prefix));
    }
    assert!(!prefixes.contains(&"/app"));
    assert!(!prefixes.contains(&"/"));
    let unique: std::collections::HashSet<_> = prefixes.iter().collect();
    assert_eq!(unique.len(), prefixes.len());
}

/// Every inventoried service that declares a path prefix must get a route in the
/// generated Caddyfile, targeting its canonical compose service name. This is
/// the guarantee that replaces the old hand-maintained route list.
#[test]
fn generates_a_route_for_every_prefixed_service() {
    let caddy = caddyfile(Mode::Local, false);
    for svc in inventory::RUST_SERVICES {
        let Some(prefix) = svc.path_prefix else {
            continue;
        };
        assert!(
            caddy.contains(&format!("reverse_proxy {}:8080", svc.compose_name)),
            "Caddyfile is missing a route to {}",
            svc.compose_name
        );
        assert!(
            caddy.contains(&format!("{prefix}/*")),
            "Caddyfile is missing the {prefix} prefix"
        );
    }
}

/// Dev keeps a single origin: services that run in Dev hit local containers;
/// Local-only prefixed services fan out to the shared-dev gateway (no strip).
#[test]
fn dev_fans_local_only_prefixes_to_the_gateway() {
    let caddy = caddyfile(Mode::Dev, false);
    for svc in inventory::RUST_SERVICES {
        let Some(prefix) = svc.path_prefix else {
            continue;
        };
        if svc.in_mode(Mode::Dev) {
            assert!(
                caddy.contains(&format!("reverse_proxy {}:8080", svc.compose_name)),
                "Dev Caddyfile missing local route for {}",
                svc.compose_name
            );
            continue;
        }
        if !svc.in_mode(Mode::Local) {
            continue;
        }
        assert!(
            !caddy.contains(&format!("reverse_proxy {}:8080", svc.compose_name)),
            "Dev must not route {} to an absent local container",
            svc.compose_name
        );
        assert!(
            caddy.contains(&format!("handle {prefix}/* {{"))
                || caddy.contains(&format!("path {prefix} {prefix}/*")),
            "Dev Caddyfile missing gateway handle for {prefix}"
        );
        assert!(
            caddy.contains(&format!("reverse_proxy {DEV_GATEWAY_ORIGIN}")),
            "Dev Caddyfile missing gateway upstream for {}",
            svc.compose_name
        );
    }
    // Concrete regression for the scheduled-action / agent-harness pair.
    assert!(caddy.contains("handle /scheduled-action/* {"));
    assert!(caddy.contains("handle /agent-harness/* {"));
    assert!(!caddy.contains("reverse_proxy scheduled_action_service:8080"));
    assert!(!caddy.contains("reverse_proxy agent_harness_service:8080"));
}

/// WebSocket services use the bare-prefix `@matcher` + explicit strip; HTTP
/// services use `handle_path`.
#[test]
fn websocket_services_use_a_matcher() {
    let caddy = caddyfile(Mode::Local, false);
    // connection-gateway is the inventoried WebSocket service.
    assert!(caddy.contains("@connection_gateway path /connection-gateway /connection-gateway/*"));
    assert!(caddy.contains("uri strip_prefix /connection-gateway"));
    // A plain HTTP service uses handle_path.
    assert!(caddy.contains("handle_path /auth/* {"));
}

/// The analytics-proxy worker is reached through the single origin at `/i/*`
/// (PostHog and OTLP traces/logs), un-stripped, on its own :8098 port.
#[test]
fn analytics_proxy_route_is_present() {
    let caddy = caddyfile(Mode::Local, false);
    assert!(caddy.contains("handle /i/* {"));
    assert!(caddy.contains("reverse_proxy analytics-proxy:8098"));
}

#[test]
fn document_content_services_are_available_through_the_proxy() {
    let caddy = caddyfile(Mode::Local, false);

    assert!(caddy.contains("uri strip_prefix /sync"));
    assert!(caddy.contains("reverse_proxy sync-service:8787"));
    assert!(caddy.contains("header_up Origin http://localhost:3000"));
    assert!(!caddyfile(Mode::Dev, false).contains("header_up Origin"));
    assert!(caddy.contains("handle_path /lexical/*"));
    assert!(caddy.contains("reverse_proxy lexical-service:8096"));
    assert!(caddy.contains("handle_path /ai-editing/*"));
    assert!(caddy.contains("reverse_proxy ai-editing-worker:8933"));
}

/// The static-file block is the one route that differs by mode: LocalStack S3
/// fan-out locally, the dev-pointed service in dev.
#[test]
fn static_file_block_is_mode_specific() {
    let local = caddyfile(Mode::Local, false);
    assert!(local.contains("/static-file-storage"));
    // A route at site scope sorts after the Vite catch-all handle and loops.
    assert!(local.contains("handle_path /static-file/*"));
    assert!(!local.contains("route /static-file/*"));
    assert!(caddyfile(Mode::Dev, false).contains("handle_path /static-file/*"));
    assert!(!caddyfile(Mode::Dev, false).contains("/static-file-storage"));
    assert!(local.contains("handle_path /local-storage/*"));
    assert!(!caddyfile(Mode::Dev, false).contains("handle_path /local-storage/*"));
}

/// Drift gate across the Rust↔TypeScript seam: every proxied service's prefix
/// must be wired into `proxyServers()` in `servers.ts`, or the frontend can't
/// reach it through the single-origin proxy. servers.ts can't be derived from
/// Rust, so this test is what keeps the two in sync.
#[test]
fn frontend_wires_every_inventory_prefix() {
    let servers = repo_root().join("apps/web/src/lib/core/constant/servers.ts");
    let src = std::fs::read_to_string(&servers)
        .unwrap_or_else(|e| panic!("reading {}: {e}", servers.display()));
    for svc in inventory::RUST_SERVICES {
        let Some(prefix) = svc.path_prefix else {
            continue;
        };
        let http = format!("${{proxyOrigin}}{prefix}");
        let ws = format!("${{wsProxyOrigin}}{prefix}");
        assert!(
            src.contains(&http) || src.contains(&ws),
            "servers.ts proxyServers() is missing prefix {prefix} (for {}); \
             the frontend can't reach it through the proxy",
            svc.compose_name
        );
    }
}

/// The static-frontend block only appears in headless mode, and serves the
/// mounted bundle under `/app` with an SPA fallback. Attached `run_local` keeps
/// forwards frontend requests to Vite instead of serving a bundle.
#[test]
fn static_frontend_block_is_opt_in() {
    let headless = caddyfile(Mode::Local, true);
    assert!(headless.contains("handle_path /app/* {"));
    assert!(headless.contains("root * /srv/frontend"));
    assert!(headless.contains("try_files {path} /index.html"));
    assert!(headless.contains("redir / \"/app/?{query}\" 302"));
    assert!(headless.contains("handle /mailpit/*"));

    let attached = caddyfile(Mode::Local, false);
    assert!(!attached.contains("/srv/frontend"));
    assert!(attached.contains("reverse_proxy host.docker.internal:{$VITE_PORT}"));
    assert!(attached.contains(&format!(
        "@backend_root path {}",
        frontend_path_prefixes().join(" ")
    )));
    assert!(attached.contains("respond @backend_root 404"));
    assert!(!headless.contains("host.docker.internal"));
    assert!(!attached.contains("redir / /app/ 302"));
    assert!(!attached.contains("handle /mailpit/*"));

    let headless_dev = caddyfile(Mode::Dev, true);
    assert!(!headless_dev.contains("handle /mailpit/*"));
}

/// Only host-run Vite needs protection from concurrent module connection bursts.
#[test]
fn vite_connection_limit_is_scoped_to_frontend() {
    for mode in [Mode::Local, Mode::Dev] {
        let attached = caddyfile(mode, false);
        assert_eq!(attached.matches("max_conns_per_host").count(), 1);
        let (backend_routes, frontend_route) = attached
            .split_once("reverse_proxy host.docker.internal:{$VITE_PORT} {")
            .expect("attached frontend must proxy to Vite");
        assert!(!backend_routes.contains("max_conns_per_host"));
        assert!(frontend_route.contains("transport http {\n                max_conns_per_host 16"));
        assert!(!caddyfile(mode, true).contains("max_conns_per_host"));
    }
}

/// Local Caddy speaks HTTPS with a machine certificate and stamps wildcard CORS
/// on every response. Dev still uses TLS (same proxy) but does not overlay
/// CORS, because it fans out to the shared-dev gateway.
#[test]
fn local_proxy_uses_tls_and_wildcard_cors() {
    let local = caddyfile(Mode::Local, false);
    assert!(local.contains("tls /etc/caddy/certs/server.pem /etc/caddy/certs/server-key.pem"));
    // Keep main's internal certificates for the separate preview listener.
    assert!(local.contains("auto_https disable_redirects"));
    assert!(local.contains("https://*.preview.localhost:8443"));
    assert!(local.contains("@cors header Origin *"));
    assert!(local.contains("@cors_preflight"));
    assert!(local.contains("Access-Control-Allow-Origin \"{http.request.header.Origin}\""));
    assert!(
        local.contains("defer"),
        "CORS overlay must defer so reverse_proxy cannot overwrite the reflected Origin"
    );
    assert!(
        !local.contains("-Access-Control-Allow-Origin"),
        "deferred -Access-Control-* deletes strip the CORS headers this overlay sets"
    );

    let dev = caddyfile(Mode::Dev, false);
    assert!(dev.contains("tls /etc/caddy/certs/server.pem /etc/caddy/certs/server-key.pem"));
    assert!(!dev.contains("@cors header Origin *"));
    assert!(!dev.contains("@cors_preflight"));
}

#[test]
fn proxy_origin_is_https() {
    let instance = crate::local::instance::Instance::derive(None, None).unwrap();
    assert_eq!(url(&instance), "https://localhost:8090");
    assert_eq!(ws_url(&instance), "wss://localhost:8090");
    assert!(
        ca_pem().is_file(),
        "checked-in CA is missing at {}",
        ca_pem().display()
    );
}