Feat/chat media in aggregator (#392)

* refactor(message_aggregator/processor): extract several private methods from process_message

* refactor(message_aggregator/processor): remove pointless retry pass

* perf(message_aggregator): replace 3 full passes by single full pass + orphans

* feat(message_aggregator): add media file information on messages

* test(media message_aggregator): add send message with media test

Author: jgmontoya

src/integration_tests/core/context.rs

@@ -1,3 +1,4 @@
+use crate::whitenoise::media_files::MediaFile;
 use crate::{Account, Whitenoise, WhitenoiseError};
 use mdk_core::prelude::group_types::Group;
 use std::collections::HashMap;
@@ -9,6 +10,7 @@ pub struct ScenarioContext {
     pub accounts: HashMap<String, Account>,
     pub groups: HashMap<String, Group>,
     pub messages_ids: HashMap<String, String>,
+    pub media_files: HashMap<String, MediaFile>,
     pub tests_count: u32,
     pub tests_passed: u32,
 }
@@ -30,6 +32,7 @@ impl ScenarioContext {
             accounts: HashMap::new(),
             groups: HashMap::new(),
             messages_ids: HashMap::new(),
+            media_files: HashMap::new(),
             tests_count: 0,
             tests_passed: 0,
         }
@@ -53,6 +56,16 @@ impl ScenarioContext {
         self.groups.get(name).ok_or(WhitenoiseError::GroupNotFound)
     }
 
+    pub fn add_media_file(&mut self, name: &str, media_file: MediaFile) {
+        self.media_files.insert(name.to_string(), media_file);
+    }
+
+    pub fn get_media_file(&self, name: &str) -> Result<&MediaFile, WhitenoiseError> {
+        self.media_files.get(name).ok_or_else(|| {
+            WhitenoiseError::Configuration(format!("Media file '{}' not found in context", name))
+        })
+    }
+
     pub fn add_message_id(&mut self, name: &str, message_id: String) {
         self.messages_ids.insert(name.to_string(), message_id);
     }

src/integration_tests/scenarios/chat_media_upload.rs

@@ -43,10 +43,17 @@ impl Scenario for ChatMediaUploadScenario {
             .execute(&mut self.context)
             .await?;
 
+        // Send a message that references the uploaded media and verify aggregation links it
+        SendMessageWithMediaTestCase::new("media_uploader", "media_upload_test_group")
+            .execute(&mut self.context)
+            .await?;
+
         tracing::info!("✓ Chat media upload scenario completed with:");
         tracing::info!("  • Image upload with default processing options");
         tracing::info!("  • Blurhash generation verification");
         tracing::info!("  • Metadata extraction and storage");
+        tracing::info!("  • Message with media reference sent");
+        tracing::info!("  • Message aggregation verified media linking");
 
         Ok(())
     }

src/integration_tests/test_cases/chat_media_upload/mod.rs

@@ -1,3 +1,5 @@
+pub mod send_message_with_media;
 pub mod upload_chat_media;
 
+pub use send_message_with_media::*;
 pub use upload_chat_media::*;

src/integration_tests/test_cases/chat_media_upload/send_message_with_media.rs

@@ -0,0 +1,162 @@
+use crate::WhitenoiseError;
+use crate::integration_tests::core::*;
+use async_trait::async_trait;
+use nostr_sdk::prelude::*;
+
+/// Test case for sending messages with media attachments and verifying aggregation links them correctly
+pub struct SendMessageWithMediaTestCase {
+    sender_account_name: String,
+    group_name: String,
+    message_content: String,
+}
+
+impl SendMessageWithMediaTestCase {
+    pub fn new(sender_account_name: &str, group_name: &str) -> Self {
+        Self {
+            sender_account_name: sender_account_name.to_string(),
+            group_name: group_name.to_string(),
+            message_content: "Check out this image! 📸".to_string(),
+        }
+    }
+
+    /// Build imeta tag per MIP-04 spec
+    /// Format: `["imeta", "url <blossom_url>", "x <hash>", "m <mime_type>", ...]`
+    fn build_imeta_tag(
+        &self,
+        hash_hex: &str,
+        blossom_url: &str,
+        mime_type: &str,
+    ) -> Result<Tag, WhitenoiseError> {
+        Tag::parse(vec![
+            "imeta",
+            &format!("url {}", blossom_url),
+            &format!("x {}", hash_hex),
+            &format!("m {}", mime_type),
+        ])
+        .map_err(|e| WhitenoiseError::Other(anyhow::anyhow!("Failed to create imeta tag: {}", e)))
+    }
+}
+
+#[async_trait]
+impl TestCase for SendMessageWithMediaTestCase {
+    async fn run(&self, context: &mut ScenarioContext) -> Result<(), WhitenoiseError> {
+        tracing::info!(
+            "Sending message with media reference to group {} from account: {}",
+            self.group_name,
+            self.sender_account_name
+        );
+
+        let sender_account = context.get_account(&self.sender_account_name)?;
+        let group = context.get_group(&self.group_name)?;
+
+        // Get the uploaded media file from context
+        let media_file = context.get_media_file("uploaded_chat_media")?;
+        let media_hash_hex = hex::encode(&media_file.file_hash);
+
+        let blossom_url = media_file.blossom_url.as_ref().ok_or_else(|| {
+            WhitenoiseError::Configuration("Uploaded media has no blossom URL".to_string())
+        })?;
+
+        let imeta_tag =
+            self.build_imeta_tag(&media_hash_hex, blossom_url, &media_file.mime_type)?;
+
+        // Send message with imeta tag
+        let send_result = context
+            .whitenoise
+            .send_message_to_group(
+                sender_account,
+                &group.mls_group_id,
+                self.message_content.clone(),
+                9, // Regular message
+                Some(vec![imeta_tag]),
+            )
+            .await?;
+
+        tracing::info!(
+            "✓ Message with media reference sent: {}",
+            send_result.message.id
+        );
+
+        // Wait for message processing
+        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+
+        // Fetch aggregated messages and verify media is linked
+        let aggregated_messages = retry(
+            15,
+            std::time::Duration::from_millis(100),
+            || async {
+                let messages = context
+                    .whitenoise
+                    .fetch_aggregated_messages_for_group(
+                        &sender_account.pubkey,
+                        &group.mls_group_id,
+                    )
+                    .await?;
+
+                if messages.is_empty() {
+                    return Err(WhitenoiseError::Other(anyhow::anyhow!(
+                        "No messages found yet"
+                    )));
+                }
+
+                Ok(messages)
+            },
+            "fetch aggregated messages with media",
+        )
+        .await?;
+
+        // Find the message we just sent
+        let sent_message_id = send_result.message.id.to_string();
+        let message_with_media = aggregated_messages
+            .iter()
+            .find(|msg| msg.id == sent_message_id)
+            .ok_or_else(|| {
+                WhitenoiseError::Other(anyhow::anyhow!(
+                    "Sent message {} not found in aggregated messages",
+                    sent_message_id
+                ))
+            })?;
+
+        // Verify media is attached
+        assert!(
+            !message_with_media.media_attachments.is_empty(),
+            "Message should have media attachments linked"
+        );
+
+        assert_eq!(
+            message_with_media.media_attachments.len(),
+            1,
+            "Message should have exactly 1 media attachment"
+        );
+
+        let attached_media = &message_with_media.media_attachments[0];
+        let attached_hash_hex = hex::encode(&attached_media.file_hash);
+        assert_eq!(
+            attached_hash_hex, media_hash_hex,
+            "Attached media hash should match uploaded file hash"
+        );
+
+        assert_eq!(
+            attached_media.mime_type, media_file.mime_type,
+            "Attached media MIME type should match uploaded file"
+        );
+
+        tracing::info!(
+            "✓ Message aggregation correctly linked media: hash={}",
+            attached_hash_hex
+        );
+
+        // Verify the message content is correct
+        assert_eq!(
+            message_with_media.content, self.message_content,
+            "Message content should match"
+        );
+
+        tracing::info!(
+            "✓ Message with media verified: {} media attachment(s) linked",
+            message_with_media.media_attachments.len()
+        );
+
+        Ok(())
+    }
+}

src/integration_tests/test_cases/chat_media_upload/upload_chat_media.rs

@@ -92,7 +92,7 @@ impl TestCase for UploadChatMediaTestCase {
             hex::encode(&media_file.file_hash)
         );
 
-        // Basic validation
+        // Validate upload results
         assert!(
             !media_file.file_hash.is_empty(),
             "File hash should not be empty"
@@ -137,6 +137,10 @@ impl TestCase for UploadChatMediaTestCase {
         );
 
         tracing::info!("✓ All media file validations passed");
+
+        // Store the media file in context for subsequent tests
+        context.add_media_file("uploaded_chat_media", media_file);
+
         Ok(())
     }
 }