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.

16.1 KB
Raw Blame
use super::*;
use crate::domain::models::{ImageAspectRatio, ReferenceImage};
use wiremock::matchers::{body_json, header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

fn image_bytes(format: image::ImageFormat) -> Vec<u8> {
    let mut bytes = std::io::Cursor::new(Vec::new());
    image::DynamicImage::new_rgb8(96, 64)
        .write_to(&mut bytes, format)
        .unwrap();
    bytes.into_inner()
}

static PNG: std::sync::LazyLock<Vec<u8>> =
    std::sync::LazyLock::new(|| image_bytes(image::ImageFormat::Png));

fn generator(server: &MockServer) -> GeminiImageGenerator {
    GeminiImageGenerator::new("test-key".to_string()).with_base_url(server.uri())
}

fn request(aspect_ratio: Option<ImageAspectRatio>) -> ImageGenerationRequest {
    ImageGenerationRequest {
        prompt: "a lighthouse at dusk".to_string(),
        aspect_ratio,
        reference_images: Vec::new(),
    }
}

fn image_response(parts: serde_json::Value) -> serde_json::Value {
    serde_json::json!({
        "candidates": [{ "content": { "role": "model", "parts": parts }, "finishReason": "STOP" }],
        "usageMetadata": { "promptTokenCount": 8, "candidatesTokenCount": 1290, "totalTokenCount": 1298 }
    })
}

#[tokio::test]
async fn posts_the_prompt_and_decodes_the_first_inline_image() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path(format!("/models/{NANO_BANANA_MODEL}:generateContent")))
        .and(header("x-goog-api-key", "test-key"))
        .and(body_json(serde_json::json!({
            "contents": [{ "role": "user", "parts": [{ "text": "a lighthouse at dusk" }] }],
            "generationConfig": {
                "responseModalities": ["IMAGE"],
                "imageConfig": { "aspectRatio": "16:9" }
            }
        })))
        .respond_with(ResponseTemplate::new(200).set_body_json(image_response(
            serde_json::json!([
                { "text": "  Here is your lighthouse. " },
                { "inlineData": { "mimeType": "image/png", "data": base64::engine::general_purpose::STANDARD.encode(&*PNG) } },
                { "inlineData": { "mimeType": "image/jpeg", "data": "AAAA" } }
            ]),
        )))
        .expect(1)
        .mount(&server)
        .await;

    let image = generator(&server)
        .generate_image(
            &request(Some(ImageAspectRatio::Widescreen)),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap();

    assert_eq!(image.bytes, *PNG);
    assert_eq!((image.width, image.height), (96, 64));
    assert_eq!(image.mime_type, "image/png");
    assert_eq!(image.note.as_deref(), Some("Here is your lighthouse."));
}

#[tokio::test]
async fn posts_ordered_reference_images_with_their_mime_types_and_exact_bytes() {
    let server = MockServer::start().await;
    let jpeg = b"\xff\xd8\xff\xe0reference";
    let prompt = "Draw the subject from image 1 in the style of image 2";
    Mock::given(method("POST"))
        .and(path(format!("/models/{NANO_BANANA_MODEL}:generateContent")))
        .and(header("x-goog-api-key", "test-key"))
        .and(body_json(serde_json::json!({
            "contents": [{
                "role": "user",
                "parts": [
                    { "text": prompt },
                    {
                        "inlineData": {
                            "mimeType": "image/png",
                            "data": base64::engine::general_purpose::STANDARD.encode(&*PNG),
                        }
                    },
                    {
                        "inlineData": {
                            "mimeType": "image/jpeg",
                            "data": base64::engine::general_purpose::STANDARD.encode(jpeg),
                        }
                    },
                ]
            }],
            "generationConfig": {
                "responseModalities": ["IMAGE"],
                "imageConfig": { "aspectRatio": "3:4" },
            }
        })))
        .respond_with(
            ResponseTemplate::new(200).set_body_json(image_response(serde_json::json!([
                { "text": "Here is the edited image." },
                {
                    "inlineData": {
                        "mimeType": "image/png",
                        "data": base64::engine::general_purpose::STANDARD.encode(&*PNG),
                    }
                },
            ]))),
        )
        .expect(1)
        .mount(&server)
        .await;

    let image = generator(&server)
        .generate_image(
            &ImageGenerationRequest {
                prompt: prompt.to_string(),
                aspect_ratio: Some(ImageAspectRatio::Portrait),
                reference_images: vec![
                    ReferenceImage {
                        bytes: PNG.to_vec(),
                        mime_type: "image/png".to_string(),
                    },
                    ReferenceImage {
                        bytes: jpeg.to_vec(),
                        mime_type: "image/jpeg".to_string(),
                    },
                ],
            },
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap();

    assert_eq!(image.bytes, *PNG);
    assert_eq!((image.width, image.height), (96, 64));
    assert_eq!(image.mime_type, "image/png");
    assert_eq!(image.note.as_deref(), Some("Here is the edited image."));
}

#[tokio::test]
async fn omits_image_config_without_an_aspect_ratio() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(image_response(
            serde_json::json!([{ "inlineData": { "mimeType": "image/png", "data": base64::engine::general_purpose::STANDARD.encode(&*PNG) } }]),
        )))
        .mount(&server)
        .await;

    generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap();

    let requests = server.received_requests().await.unwrap();
    let body: serde_json::Value = serde_json::from_slice(&requests[0].body).unwrap();
    assert_eq!(
        body["generationConfig"],
        serde_json::json!({ "responseModalities": ["IMAGE"] })
    );
}

#[tokio::test]
async fn text_only_and_blocked_responses_are_refusals() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(image_response(
            serde_json::json!([{ "text": "I can't draw that." }]),
        )))
        .up_to_n_times(1)
        .mount(&server)
        .await;
    let error = generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap_err();
    assert!(
        matches!(&error, ImageGenerationError::Refused(reason) if reason.contains("I can't draw that.")),
        "{error:?}"
    );

    server.reset().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "promptFeedback": { "blockReason": "PROHIBITED_CONTENT" }
        })))
        .mount(&server)
        .await;
    let error = generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap_err();
    assert!(
        matches!(&error, ImageGenerationError::Refused(reason) if reason.contains("PROHIBITED_CONTENT")),
        "{error:?}"
    );

    server.reset().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "candidates": [{ "finishReason": "IMAGE_SAFETY" }]
        })))
        .mount(&server)
        .await;
    let error = generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap_err();
    assert!(
        matches!(&error, ImageGenerationError::Refused(reason) if reason.contains("IMAGE_SAFETY")),
        "{error:?}"
    );
}

#[tokio::test]
async fn http_errors_surface_the_provider_message() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(429).set_body_json(serde_json::json!({
            "error": { "code": 429, "message": "Resource has been exhausted", "status": "RESOURCE_EXHAUSTED" }
        })))
        .mount(&server)
        .await;

    let error = generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &ai_usage::NoOpUsageRecorder,
        )
        .await
        .unwrap_err();
    match error {
        ImageGenerationError::Provider(error) => {
            let message = format!("{error:#}");
            assert!(message.contains("429"), "{message}");
            assert!(message.contains("Resource has been exhausted"), "{message}");
        }
        other => panic!("expected a provider error, got {other:?}"),
    }
}

#[tokio::test]
async fn invalid_base64_is_a_provider_error() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(image_response(
            serde_json::json!([{ "inlineData": { "mimeType": "image/png", "data": "not base64!" } }]),
        )))
        .mount(&server)
        .await;

    assert!(matches!(
        generator(&server)
            .generate_image(
                &request(None),
                &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
                &ai_usage::NoOpUsageRecorder
            )
            .await
            .unwrap_err(),
        ImageGenerationError::Provider(_)
    ));
}

#[test]
fn reads_actual_dimensions_for_supported_image_formats() {
    for (format, mime) in [
        (image::ImageFormat::Png, "image/png"),
        (image::ImageFormat::Jpeg, "image/jpeg"),
        (image::ImageFormat::WebP, "image/webp"),
        (image::ImageFormat::Gif, "image/gif"),
    ] {
        let response: GenerateContentResponse =
            serde_json::from_value(image_response(serde_json::json!([{ "inlineData": {
                "mimeType": mime,
                "data": base64::engine::general_purpose::STANDARD.encode(image_bytes(format)),
            }}])))
            .unwrap();
        let image = response.into_image().unwrap();
        assert_eq!((image.width, image.height), (96, 64), "{mime}");
    }
}

#[test]
fn rejects_image_bytes_without_readable_dimensions() {
    let response: GenerateContentResponse =
        serde_json::from_value(image_response(serde_json::json!([{ "inlineData": {
            "mimeType": "image/png",
            "data": base64::engine::general_purpose::STANDARD.encode(b"not an image"),
        }}])))
        .unwrap();
    assert!(matches!(
        response.into_image(),
        Err(ImageGenerationError::Provider(_))
    ));
}

#[derive(Default)]
struct RecordingUsage(std::sync::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 records_provider_counts_before_image_decoding_or_refusal() {
    for parts in [
        serde_json::json!([{ "inlineData": { "mimeType": "image/png", "data": base64::engine::general_purpose::STANDARD.encode(&*PNG) } }]),
        serde_json::json!([{ "inlineData": { "mimeType": "image/png", "data": "bad base64!" } }]),
        serde_json::json!([{ "text": "Cannot generate this image" }]),
    ] {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .respond_with(ResponseTemplate::new(200).set_body_json(image_response(parts)))
            .expect(1)
            .mount(&server)
            .await;
        let recorder = RecordingUsage::default();
        let user = macro_user_id::user_id::MacroUserIdStr::try_from(
            "macro|[email protected]".to_string(),
        )
        .unwrap();
        let usage = UsageContext::new(ai_usage::AiFeature::ImageGeneration, user.clone());
        let _ = generator(&server)
            .generate_image(&request(None), &usage, &recorder)
            .await;
        let events = recorder.0.lock().unwrap();
        assert_eq!(events.len(), 1);
        assert_eq!(events[0].user, user);
        assert_eq!(events[0].feature, ai_usage::AiFeature::ImageGeneration);
        assert_eq!(events[0].model, NANO_BANANA_MODEL);
        assert_eq!(
            events[0].amount,
            ai_usage::UsageAmount::Tokens {
                input: 8,
                output: 1290,
                cache_read: 0,
                cache_write: 0,
            }
        );
    }
}

#[tokio::test]
async fn blocked_prompt_records_reported_input_without_inventing_output() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "promptFeedback": { "blockReason": "SAFETY" },
            "usageMetadata": { "promptTokenCount": 12, "totalTokenCount": 12 }
        })))
        .mount(&server)
        .await;
    let recorder = RecordingUsage::default();
    assert!(
        generator(&server)
            .generate_image(
                &request(None),
                &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
                &recorder,
            )
            .await
            .is_err()
    );
    let events = recorder.0.lock().unwrap();
    assert_eq!(events.len(), 1);
    assert_eq!(
        events[0].amount,
        ai_usage::UsageAmount::Tokens {
            input: 12,
            output: 0,
            cache_read: 0,
            cache_write: 0,
        }
    );
}

#[tokio::test]
async fn absent_metadata_and_http_errors_do_not_fabricate_usage() {
    for (status, body) in [
        (
            200,
            serde_json::json!({ "candidates": [{ "content": { "parts": [
            { "inlineData": { "mimeType": "image/png", "data": base64::engine::general_purpose::STANDARD.encode(&*PNG) } }
        ] } }] }),
        ),
        (
            429,
            serde_json::json!({ "error": { "message": "quota exceeded" } }),
        ),
    ] {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .respond_with(ResponseTemplate::new(status).set_body_json(body))
            .mount(&server)
            .await;
        let recorder = RecordingUsage::default();
        let result = generator(&server)
            .generate_image(
                &request(None),
                &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
                &recorder,
            )
            .await;
        assert_eq!(result.is_ok(), status == 200);
        assert!(recorder.0.lock().unwrap().is_empty());
    }
}

#[tokio::test]
async fn uses_total_minus_prompt_when_candidate_count_is_absent() {
    let server = MockServer::start().await;
    let mut body = image_response(serde_json::json!([
        { "inlineData": { "mimeType": "image/png", "data": base64::engine::general_purpose::STANDARD.encode(&*PNG) } }
    ]));
    body["usageMetadata"]
        .as_object_mut()
        .unwrap()
        .remove("candidatesTokenCount");
    Mock::given(method("POST"))
        .respond_with(ResponseTemplate::new(200).set_body_json(body))
        .mount(&server)
        .await;
    let recorder = RecordingUsage::default();
    generator(&server)
        .generate_image(
            &request(None),
            &UsageContext::system(ai_usage::AiFeature::ImageGeneration),
            &recorder,
        )
        .await
        .unwrap();
    let events = recorder.0.lock().unwrap();
    assert_eq!(events.len(), 1);
    assert_eq!(
        events[0].amount,
        ai_usage::UsageAmount::Tokens {
            input: 8,
            output: 1290,
            cache_read: 0,
            cache_write: 0,
        }
    );
}