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.2 KB
Raw Blame
use super::*;
use crate::domain::models::{
    GeneratedImage, ImageAspectRatio, ImageReference, ReadImageError, ReferenceImage,
    SaveImageError, StoredImage,
};
use crate::domain::ports::UnconfiguredImageGenerator;
use macro_user_id::user_id::MacroUserIdStr;
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use uuid::Uuid;

const STATIC_FILE_ID: Uuid = Uuid::from_u128(0x123);
const PNG: &[u8] = b"\x89PNG\r\n\x1a\nfake";
const DOCUMENT_REFERENCE: ImageReference = ImageReference::Document(Uuid::from_u128(0x456));
const STATIC_REFERENCE: ImageReference = ImageReference::StaticFile(Uuid::from_u128(0x789));

fn principal() -> CreationPrincipal {
    CreationPrincipal::BotForUser {
        bot: bot_id::MACRO_AI_BOT_ID,
        user: MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap(),
    }
}

#[derive(Default)]
struct RecordingStore {
    saves: Mutex<Vec<NewStaticImage>>,
    fail: bool,
}

impl ImageStore for Arc<RecordingStore> {
    async fn save_image(&self, image: NewStaticImage) -> Result<StoredImage, SaveImageError> {
        if self.fail {
            return Err(SaveImageError::Internal(rootcause::report!(
                "upload failed"
            )));
        }
        self.saves.lock().unwrap().push(image);
        Ok(StoredImage {
            id: STATIC_FILE_ID,
            url: "https://static.example/file/image".to_string(),
        })
    }
}

/// Returns a fixed image and records what it was asked for.
struct FakeGenerator {
    requests: Mutex<Vec<ImageGenerationRequest>>,
    result: Result<GeneratedImage, &'static str>,
}

impl FakeGenerator {
    fn returning(image: GeneratedImage) -> Self {
        Self {
            requests: Mutex::default(),
            result: Ok(image),
        }
    }

    fn refusing(reason: &'static str) -> Self {
        Self {
            requests: Mutex::default(),
            result: Err(reason),
        }
    }
}

#[async_trait::async_trait]
impl ImageGenerator for FakeGenerator {
    async fn generate_image(
        &self,
        request: &ImageGenerationRequest,
        usage: &UsageContext,
        recorder: &dyn UsageRecorder,
    ) -> Result<GeneratedImage, ImageGenerationError> {
        self.requests.lock().unwrap().push(request.clone());
        recorder.record(usage.clone().into_event(
            "gemini-2.5-flash-image".to_string(),
            ai_usage::UsageAmount::Tokens {
                input: 8,
                output: 1290,
                cache_read: 0,
                cache_write: 0,
            },
        ));
        self.result
            .clone()
            .map_err(|reason| ImageGenerationError::Refused(reason.to_string()))
    }
}

#[derive(Default)]
struct RecordingComposer {
    calls: Mutex<Vec<(Uuid, String, u32, u32)>>,
    fail: bool,
}

#[async_trait::async_trait]
impl ImageMarkdownComposer for RecordingComposer {
    async fn compose_image(
        &self,
        image: &StoredImage,
        width: u32,
        height: u32,
    ) -> Result<String, crate::domain::models::ComposeImageError> {
        self.calls
            .lock()
            .unwrap()
            .push((image.id, image.url.clone(), width, height));
        if self.fail {
            return Err(crate::domain::models::ComposeImageError(
                rootcause::report!("lexical unavailable"),
            ));
        }
        Ok("markup returned by Lexical".to_string())
    }
}

fn test_service(
    generator: Arc<dyn ImageGenerator>,
    store: Arc<RecordingStore>,
) -> ImageGenerationServiceImpl<Arc<RecordingStore>> {
    ImageGenerationServiceImpl::new(
        generator,
        store,
        Arc::new(RecordingComposer::default()),
        Arc::new(ai_usage::NoOpUsageRecorder),
    )
}

fn png() -> GeneratedImage {
    GeneratedImage {
        width: 1536,
        height: 1024,
        bytes: PNG.to_vec(),
        mime_type: "image/png".to_string(),
        note: Some("A calm scene.".to_string()),
    }
}

fn request(prompt: &str) -> NewGeneratedImage {
    NewGeneratedImage {
        prompt: prompt.to_string(),
        aspect_ratio: Some(ImageAspectRatio::Widescreen),
        reference_images: Vec::new(),
    }
}

#[tokio::test]
async fn generates_then_uploads_bytes_and_returns_the_static_file() {
    let store = Arc::new(RecordingStore::default());
    let generator = Arc::new(FakeGenerator::returning(png()));
    let service = test_service(generator.clone(), store.clone());
    let created = service
        .create_generated_image(&principal(), request("  a lighthouse at dusk "))
        .await
        .unwrap();
    assert_eq!(created.static_file.id, STATIC_FILE_ID);
    assert_eq!(created.static_file.url, "https://static.example/file/image");
    assert_eq!(created.mime_type, "image/png");
    assert_eq!((created.width, created.height), (1536, 1024));
    assert_eq!(created.size_bytes, PNG.len());
    assert_eq!(created.note.as_deref(), Some("A calm scene."));
    assert_eq!(
        *generator.requests.lock().unwrap(),
        [ImageGenerationRequest {
            prompt: "a lighthouse at dusk".to_string(),
            aspect_ratio: Some(ImageAspectRatio::Widescreen),
            reference_images: Vec::new(),
        }]
    );
    let saves = store.saves.lock().unwrap();
    assert_eq!(saves.len(), 1);
    assert_eq!(saves[0].bytes, PNG);
    assert_eq!(saves[0].mime_type, "image/png");
}

#[tokio::test]
async fn rejects_bad_input_before_calling_the_provider() {
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let service = test_service(generator.clone(), store.clone());
    for image in [request("   "), request(&"p".repeat(MAX_PROMPT_BYTES + 1))] {
        assert!(matches!(
            service.create_generated_image(&principal(), image).await,
            Err(GenerateImageError::BadRequest(_))
        ));
    }
    assert!(generator.requests.lock().unwrap().is_empty());
    assert!(store.saves.lock().unwrap().is_empty());
}

#[tokio::test]
async fn provider_failures_upload_no_image() {
    let store = Arc::new(RecordingStore::default());
    let service = test_service(
        Arc::new(FakeGenerator::refusing("blocked by safety filters")),
        store.clone(),
    );
    assert!(
        matches!(service.create_generated_image(&principal(), request("prompt")).await,
        Err(GenerateImageError::Generation(ImageGenerationError::Refused(ref reason))) if reason == "blocked by safety filters")
    );
    let service = test_service(Arc::new(UnconfiguredImageGenerator), store.clone());
    assert!(matches!(
        service
            .create_generated_image(&principal(), request("prompt"))
            .await,
        Err(GenerateImageError::Generation(
            ImageGenerationError::Unavailable
        ))
    ));
    for image in [
        GeneratedImage {
            mime_type: "application/pdf".to_string(),
            ..png()
        },
        GeneratedImage {
            bytes: Vec::new(),
            ..png()
        },
    ] {
        let service = test_service(Arc::new(FakeGenerator::returning(image)), store.clone());
        assert!(matches!(
            service
                .create_generated_image(&principal(), request("prompt"))
                .await,
            Err(GenerateImageError::Generation(
                ImageGenerationError::Provider(_)
            ))
        ));
    }
    assert!(store.saves.lock().unwrap().is_empty());
}

#[tokio::test]
async fn propagates_static_file_upload_failures() {
    let service = test_service(
        Arc::new(FakeGenerator::returning(png())),
        Arc::new(RecordingStore {
            fail: true,
            ..Default::default()
        }),
    );
    assert!(matches!(
        service
            .create_generated_image(&principal(), request("prompt"))
            .await,
        Err(GenerateImageError::Storage(SaveImageError::Internal(_)))
    ));
}

struct RecordingReader {
    calls: Mutex<Vec<(CreationPrincipal, ImageReference)>>,
    results: Mutex<VecDeque<Result<ReferenceImage, ReadImageError>>>,
}

impl RecordingReader {
    fn returning(results: Vec<Result<ReferenceImage, ReadImageError>>) -> Self {
        Self {
            calls: Mutex::default(),
            results: Mutex::new(results.into()),
        }
    }
}

impl ImageReferenceReader for Arc<RecordingReader> {
    async fn read_image(
        &self,
        principal: &CreationPrincipal,
        reference: &ImageReference,
    ) -> Result<ReferenceImage, ReadImageError> {
        self.calls
            .lock()
            .unwrap()
            .push((principal.clone(), *reference));
        self.results
            .lock()
            .unwrap()
            .pop_front()
            .expect("unexpected reference read")
    }
}

fn reference_image(bytes: Vec<u8>, mime_type: &str) -> ReferenceImage {
    ReferenceImage {
        bytes,
        mime_type: mime_type.to_string(),
    }
}

#[tokio::test]
async fn resolves_references_in_order_under_the_creating_principal_before_generation() {
    let images = vec![
        reference_image(PNG.to_vec(), "image/png"),
        reference_image(b"reference jpeg".to_vec(), "image/jpeg"),
    ];
    let reader = Arc::new(RecordingReader::returning(
        images.iter().cloned().map(Ok).collect(),
    ));
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let service =
        test_service(generator.clone(), store.clone()).with_reference_reader(reader.clone());
    let mut image = request("  edit image 1 using image 2  ");
    image.reference_images = vec![DOCUMENT_REFERENCE, STATIC_REFERENCE];

    let created = service
        .create_generated_image(&principal(), image)
        .await
        .unwrap();

    assert_eq!(created.static_file.id, STATIC_FILE_ID);
    assert_eq!(
        *reader.calls.lock().unwrap(),
        [
            (principal(), DOCUMENT_REFERENCE),
            (principal(), STATIC_REFERENCE)
        ]
    );
    assert_eq!(
        *generator.requests.lock().unwrap(),
        [ImageGenerationRequest {
            prompt: "edit image 1 using image 2".to_string(),
            aspect_ratio: Some(ImageAspectRatio::Widescreen),
            reference_images: images,
        }]
    );
    let saves = store.saves.lock().unwrap();
    assert_eq!(saves.len(), 1);
    assert_eq!(saves[0].bytes, PNG);
    assert_eq!(saves[0].mime_type, "image/png");
}

#[tokio::test]
async fn excessive_reference_count_is_rejected_before_any_read_or_generation() {
    let reader = Arc::new(RecordingReader::returning(Vec::new()));
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let service =
        test_service(generator.clone(), store.clone()).with_reference_reader(reader.clone());
    let mut image = request("edit these images");
    image.reference_images = vec![DOCUMENT_REFERENCE; MAX_REFERENCE_IMAGES + 1];

    assert!(matches!(
        service.create_generated_image(&principal(), image).await,
        Err(GenerateImageError::BadRequest(_))
    ));
    assert!(reader.calls.lock().unwrap().is_empty());
    assert!(generator.requests.lock().unwrap().is_empty());
    assert!(store.saves.lock().unwrap().is_empty());
}

#[tokio::test]
async fn failed_reference_reads_never_generate_from_a_partial_set() {
    for error in [
        ReadImageError::Unauthorized,
        ReadImageError::NotImage,
        ReadImageError::Unavailable,
        ReadImageError::Internal(rootcause::report!("storage unavailable")),
    ] {
        let expected_error = error.to_string();
        let reader = Arc::new(RecordingReader::returning(vec![
            Ok(reference_image(PNG.to_vec(), "image/png")),
            Err(error),
        ]));
        let generator = Arc::new(FakeGenerator::returning(png()));
        let store = Arc::new(RecordingStore::default());
        let service =
            test_service(generator.clone(), store.clone()).with_reference_reader(reader.clone());
        let mut image = request("combine all three images");
        image.reference_images = vec![DOCUMENT_REFERENCE, STATIC_REFERENCE, DOCUMENT_REFERENCE];

        assert!(matches!(
            service.create_generated_image(&principal(), image).await,
            Err(GenerateImageError::Reference(error)) if error.to_string() == expected_error
        ));
        assert_eq!(reader.calls.lock().unwrap().len(), 2);
        assert!(generator.requests.lock().unwrap().is_empty());
        assert!(store.saves.lock().unwrap().is_empty());
    }
}

#[tokio::test]
async fn invalid_reference_content_is_rejected_before_generation_or_storage() {
    for images in [
        vec![reference_image(PNG.to_vec(), "image/gif")],
        vec![reference_image(Vec::new(), "image/png")],
        vec![reference_image(
            vec![0; MAX_REFERENCE_BYTES + 1],
            "image/png",
        )],
        vec![
            reference_image(vec![0; MAX_REFERENCE_BYTES / 2], "image/png"),
            reference_image(vec![0; MAX_REFERENCE_BYTES / 2 + 1], "image/webp"),
        ],
    ] {
        let image_count = images.len();
        let reader = Arc::new(RecordingReader::returning(
            images.into_iter().map(Ok).collect(),
        ));
        let generator = Arc::new(FakeGenerator::returning(png()));
        let store = Arc::new(RecordingStore::default());
        let service =
            test_service(generator.clone(), store.clone()).with_reference_reader(reader.clone());
        let mut image = request("edit these images");
        image.reference_images = vec![DOCUMENT_REFERENCE; image_count];

        assert!(matches!(
            service.create_generated_image(&principal(), image).await,
            Err(GenerateImageError::BadRequest(_))
        ));
        assert_eq!(reader.calls.lock().unwrap().len(), image_count);
        assert!(generator.requests.lock().unwrap().is_empty());
        assert!(store.saves.lock().unwrap().is_empty());
    }
}

#[tokio::test]
async fn accepts_three_supported_images_at_the_total_byte_limit() {
    let images = vec![
        reference_image(vec![0; MAX_REFERENCE_BYTES - 2], "image/png"),
        reference_image(vec![1], "image/jpeg"),
        reference_image(vec![2], "image/webp"),
    ];
    let reader = Arc::new(RecordingReader::returning(
        images.into_iter().map(Ok).collect(),
    ));
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let service = test_service(generator.clone(), store.clone()).with_reference_reader(reader);
    let mut image = request("combine all three images");
    image.reference_images = vec![DOCUMENT_REFERENCE, STATIC_REFERENCE, DOCUMENT_REFERENCE];

    service
        .create_generated_image(&principal(), image)
        .await
        .unwrap();

    let requests = generator.requests.lock().unwrap();
    assert_eq!(requests.len(), 1);
    assert_eq!(requests[0].reference_images.len(), MAX_REFERENCE_IMAGES);
    assert_eq!(
        requests[0]
            .reference_images
            .iter()
            .map(|image| image.bytes.len())
            .sum::<usize>(),
        MAX_REFERENCE_BYTES
    );
    assert_eq!(store.saves.lock().unwrap().len(), 1);
}

#[tokio::test]
async fn missing_reference_reader_does_not_silently_fall_back_to_text_only() {
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let service = test_service(generator.clone(), store.clone());
    let mut image = request("edit this photo");
    image.reference_images = vec![DOCUMENT_REFERENCE];

    assert!(matches!(
        service.create_generated_image(&principal(), image).await,
        Err(GenerateImageError::Reference(ReadImageError::Unavailable))
    ));
    assert!(generator.requests.lock().unwrap().is_empty());
    assert!(store.saves.lock().unwrap().is_empty());
}

#[tokio::test]
async fn delegates_saved_image_dimensions_to_the_composer() {
    let store = Arc::new(RecordingStore::default());
    let composer = Arc::new(RecordingComposer::default());
    let service = ImageGenerationServiceImpl::new(
        Arc::new(FakeGenerator::returning(png())),
        store,
        composer.clone(),
        Arc::new(ai_usage::NoOpUsageRecorder),
    );
    let created = service
        .create_generated_image(&principal(), request("image"))
        .await
        .unwrap();
    assert_eq!(created.markdown, "markup returned by Lexical");
    assert_eq!(
        *composer.calls.lock().unwrap(),
        [(STATIC_FILE_ID, created.static_file.url, 1536, 1024)]
    );
}

#[tokio::test]
async fn reports_composition_failure_after_saving_the_image() {
    let store = Arc::new(RecordingStore::default());
    let service = ImageGenerationServiceImpl::new(
        Arc::new(FakeGenerator::returning(png())),
        store.clone(),
        Arc::new(RecordingComposer {
            fail: true,
            ..Default::default()
        }),
        Arc::new(ai_usage::NoOpUsageRecorder),
    );
    assert!(matches!(
        service
            .create_generated_image(&principal(), request("image"))
            .await,
        Err(GenerateImageError::Markup(_))
    ));
    assert_eq!(store.saves.lock().unwrap().len(), 1);
}

#[derive(Default)]
struct RecordingUsage(Mutex<Vec<ai_usage::UsageEvent>>);

impl UsageRecorder for RecordingUsage {
    fn record(&self, event: ai_usage::UsageEvent) {
        self.0.lock().unwrap().push(event);
    }
}

#[tokio::test]
async fn attributes_usage_to_the_user_even_when_upload_fails() {
    for fail in [false, true] {
        let recorder = Arc::new(RecordingUsage::default());
        let service = ImageGenerationServiceImpl::new(
            Arc::new(FakeGenerator::returning(png())),
            Arc::new(RecordingStore {
                fail,
                ..Default::default()
            }),
            Arc::new(RecordingComposer::default()),
            recorder.clone(),
        )
        .with_reference_reader(Arc::new(RecordingReader::returning(Vec::new())));
        let result = service
            .create_generated_image(&principal(), request("draw a cat"))
            .await;
        assert_eq!(result.is_err(), fail);
        let events = recorder.0.lock().unwrap();
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].feature, AiFeature::ImageGeneration);
        assert_eq!(&events[0].user, principal().user().unwrap());
        assert_eq!(events[0].entity, None);
        assert_eq!(
            events[0].amount,
            ai_usage::UsageAmount::Tokens {
                input: 8,
                output: 1290,
                cache_read: 0,
                cache_write: 0,
            }
        );
    }
}

#[tokio::test]
async fn invalid_requests_do_not_record_usage() {
    let recorder = Arc::new(RecordingUsage::default());
    let service = ImageGenerationServiceImpl::new(
        Arc::new(FakeGenerator::returning(png())),
        Arc::new(RecordingStore::default()),
        Arc::new(RecordingComposer::default()),
        recorder.clone(),
    );
    assert!(
        service
            .create_generated_image(&principal(), request(" "))
            .await
            .is_err()
    );
    assert!(recorder.0.lock().unwrap().is_empty());
}

#[tokio::test]
async fn direct_users_and_team_bots_have_distinct_usage_attribution() {
    let user = principal().user().unwrap().clone();
    let team_bot = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id::BotId::new_from_uuid(Uuid::from_u128(42)))
            .unwrap(),
        team: Uuid::from_u128(43),
    };
    for (principal, expected_user) in [
        (CreationPrincipal::User(user.clone()), user),
        (team_bot, ai_usage::SYSTEM_USER_ID.clone()),
    ] {
        let recorder = Arc::new(RecordingUsage::default());
        let service = ImageGenerationServiceImpl::new(
            Arc::new(FakeGenerator::returning(png())),
            Arc::new(RecordingStore::default()),
            Arc::new(RecordingComposer::default()),
            recorder.clone(),
        );
        service
            .create_generated_image(&principal, request("draw a cat"))
            .await
            .unwrap();
        let events = recorder.0.lock().unwrap();
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].user, expected_user);
    }
}

/// Records who was admitted for which feature and answers with a fixed result.
struct RecordingAdmission {
    result: Result<(), ai_billing::AiAdmissionError>,
    admitted: Mutex<Vec<(String, AiFeature)>>,
}

impl RecordingAdmission {
    fn new(result: Result<(), ai_billing::AiAdmissionError>) -> Arc<Self> {
        Arc::new(Self {
            result,
            admitted: Mutex::default(),
        })
    }
}

impl AiAdmissionService for RecordingAdmission {
    fn admit<'a>(
        &'a self,
        user: &'a MacroUserIdStr<'_>,
        feature: AiFeature,
    ) -> ai_billing::domain::admission::AdmissionFuture<'a> {
        self.admitted
            .lock()
            .unwrap()
            .push((user.to_string(), feature));
        let result = self.result;
        Box::pin(async move { result })
    }
}

#[tokio::test]
async fn admitted_service_charges_the_acting_user_before_generating() {
    let generator = Arc::new(FakeGenerator::returning(png()));
    let admission = RecordingAdmission::new(Ok(()));
    let service = AdmittedImageGenerationService::new(
        Arc::new(test_service(
            generator.clone(),
            Arc::new(RecordingStore::default()),
        )),
        admission.clone(),
    );
    let created = service
        .create_generated_image(&principal(), request("draw a cat"))
        .await
        .unwrap();
    assert_eq!(created.static_file.id, STATIC_FILE_ID);
    assert_eq!(
        *admission.admitted.lock().unwrap(),
        [(
            "macro|[email protected]".to_string(),
            AiFeature::ImageGeneration
        )]
    );
    assert_eq!(generator.requests.lock().unwrap().len(), 1);
}

#[tokio::test]
async fn admitted_service_generates_nothing_when_admission_refuses() {
    let generator = Arc::new(FakeGenerator::returning(png()));
    let store = Arc::new(RecordingStore::default());
    let denied = ai_billing::AiAdmissionError::Denied(ai_billing::DenyReason::AllowanceExhausted);
    let service = AdmittedImageGenerationService::new(
        Arc::new(test_service(generator.clone(), store.clone())),
        RecordingAdmission::new(Err(denied)),
    );
    assert!(matches!(
        service
            .create_generated_image(&principal(), request("draw a cat"))
            .await,
        Err(GenerateImageError::Admission(error)) if error == denied
    ));
    assert!(generator.requests.lock().unwrap().is_empty());
    assert!(store.saves.lock().unwrap().is_empty());
}

#[tokio::test]
async fn admitted_service_refuses_team_bots_with_no_user_to_bill() {
    let generator = Arc::new(FakeGenerator::returning(png()));
    let admission = RecordingAdmission::new(Ok(()));
    let service = AdmittedImageGenerationService::new(
        Arc::new(test_service(
            generator.clone(),
            Arc::new(RecordingStore::default()),
        )),
        admission.clone(),
    );
    let team_bot = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id::BotId::new_from_uuid(Uuid::from_u128(42)))
            .unwrap(),
        team: Uuid::from_u128(43),
    };
    assert!(matches!(
        service
            .create_generated_image(&team_bot, request("draw a cat"))
            .await,
        Err(GenerateImageError::UserRequired)
    ));
    assert!(admission.admitted.lock().unwrap().is_empty());
    assert!(generator.requests.lock().unwrap().is_empty());
}