code refactor

Reviewed-on: #26

crates/adapters/image-converter/tests/backfill_job_test.rs

@@ -0,0 +1,91 @@
+use std::sync::{Arc, Mutex};
+
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{EventPublisher, ImageRefQuery, PeriodicJob},
+};
+use image_converter::ConversionBackfillJob;
+
+struct MockImageRef {
+    keys: Vec<String>,
+}
+
+#[async_trait::async_trait]
+impl ImageRefQuery for MockImageRef {
+    async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
+        Ok(self.keys.clone())
+    }
+}
+
+struct MockPublisher {
+    emitted: Mutex<Vec<String>>,
+}
+
+impl MockPublisher {
+    fn new() -> Arc<Self> {
+        Arc::new(Self {
+            emitted: Mutex::new(vec![]),
+        })
+    }
+
+    fn emitted(&self) -> Vec<String> {
+        self.emitted.lock().unwrap().clone()
+    }
+}
+
+#[async_trait::async_trait]
+impl EventPublisher for MockPublisher {
+    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
+        if let DomainEvent::ImageStored { key } = event {
+            self.emitted.lock().unwrap().push(key.clone());
+        }
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn emits_image_stored_for_unconverted_keys() {
+    let image_ref = Arc::new(MockImageRef {
+        keys: vec!["avatars/u1".into(), "posters/m1".into()],
+    });
+    let publisher = MockPublisher::new();
+    let job =
+        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
+
+    job.run().await.unwrap();
+
+    let mut emitted = publisher.emitted();
+    emitted.sort();
+    assert_eq!(emitted, vec!["avatars/u1", "posters/m1"]);
+}
+
+#[tokio::test]
+async fn skips_already_converted_keys() {
+    let image_ref = Arc::new(MockImageRef {
+        keys: vec![
+            "avatars/u1.avif".into(),
+            "posters/m1".into(),
+            "avatars/u2.webp".into(),
+        ],
+    });
+    let publisher = MockPublisher::new();
+    let job =
+        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
+
+    job.run().await.unwrap();
+
+    assert_eq!(publisher.emitted(), vec!["posters/m1"]);
+}
+
+#[tokio::test]
+async fn empty_keys_emits_nothing() {
+    let image_ref = Arc::new(MockImageRef { keys: vec![] });
+    let publisher = MockPublisher::new();
+    let job =
+        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
+
+    job.run().await.unwrap();
+
+    assert!(publisher.emitted().is_empty());
+}

crates/adapters/image-converter/tests/conversion_config_test.rs

@@ -0,0 +1,54 @@
+use image_converter::{ConversionConfig, Format};
+
+fn section(enabled: bool, format: Option<&str>) -> config::ImageConversionConfig {
+    config::ImageConversionConfig {
+        enabled,
+        format: format.map(str::to_owned),
+    }
+}
+
+fn convert(enabled: bool, format: Option<&str>) -> anyhow::Result<Option<ConversionConfig>> {
+    ConversionConfig::from_config(&section(enabled, format))
+}
+
+#[test]
+fn is_disabled_by_default() {
+    assert!(
+        ConversionConfig::from_config(&config::ImageConversionConfig::default())
+            .unwrap()
+            .is_none()
+    );
+    assert!(convert(false, Some("webp")).unwrap().is_none());
+}
+
+#[test]
+fn enabled_with_avif_format() {
+    let cfg = convert(true, Some("avif")).unwrap().unwrap();
+    assert_eq!(cfg.format, Format::Avif);
+}
+
+#[test]
+fn enabled_with_webp_format() {
+    let cfg = convert(true, Some("webp")).unwrap().unwrap();
+    assert_eq!(cfg.format, Format::Webp);
+}
+
+#[test]
+fn unknown_format_is_rejected() {
+    assert!(convert(true, Some("gif")).is_err());
+}
+
+#[test]
+fn missing_format_when_enabled_is_rejected() {
+    assert!(convert(true, None).is_err());
+}
+
+#[test]
+fn avif_extension_is_dot_avif() {
+    assert_eq!(Format::Avif.extension(), ".avif");
+}
+
+#[test]
+fn webp_extension_is_dot_webp() {
+    assert_eq!(Format::Webp.extension(), ".webp");
+}

crates/adapters/image-converter/tests/conversion_handler_test.rs

@@ -0,0 +1,193 @@
+use std::sync::{Arc, Mutex};
+
+use domain::{
+    errors::DomainError,
+    events::DomainEvent,
+    ports::{EventHandler, ImageRefCommand, ObjectStorage},
+};
+use image_converter::{Format, ImageConversionHandler};
+use object_storage::ObjectStorageAdapter;
+use object_store::memory::InMemory;
+
+struct MockImageRef {
+    swaps: Mutex<Vec<(String, String)>>,
+}
+
+impl MockImageRef {
+    fn new() -> Arc<Self> {
+        Arc::new(Self {
+            swaps: Mutex::new(vec![]),
+        })
+    }
+
+    fn swaps(&self) -> Vec<(String, String)> {
+        self.swaps.lock().unwrap().clone()
+    }
+}
+
+#[async_trait::async_trait]
+impl ImageRefCommand for MockImageRef {
+    async fn swap(&self, old: &str, new: &str) -> Result<(), DomainError> {
+        self.swaps.lock().unwrap().push((old.into(), new.into()));
+        Ok(())
+    }
+}
+
+fn in_memory_storage() -> Arc<ObjectStorageAdapter> {
+    Arc::new(ObjectStorageAdapter::new(Arc::new(InMemory::new())))
+}
+
+fn tiny_jpeg() -> Vec<u8> {
+    use image::{DynamicImage, ImageBuffer, Rgb};
+    let img = DynamicImage::ImageRgb8(ImageBuffer::from_pixel(4, 4, Rgb([200u8, 100, 50])));
+    let mut buf = std::io::Cursor::new(Vec::new());
+    img.write_to(&mut buf, image::ImageFormat::Jpeg).unwrap();
+    buf.into_inner()
+}
+
+#[tokio::test]
+async fn ignores_non_image_stored_events() {
+    let storage = in_memory_storage();
+    let image_ref = MockImageRef::new();
+    let handler = ImageConversionHandler::new(
+        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+        Format::Avif,
+    );
+
+    handler
+        .handle(&DomainEvent::UserUpdated {
+            user_id: domain::value_objects::UserId::from_uuid(uuid::Uuid::new_v4()),
+        })
+        .await
+        .unwrap();
+
+    assert!(image_ref.swaps().is_empty());
+}
+
+#[tokio::test]
+async fn skips_already_converted_avif_key() {
+    let storage = in_memory_storage();
+    storage
+        .store("avatars/u1.avif", &tiny_jpeg())
+        .await
+        .unwrap();
+    let image_ref = MockImageRef::new();
+    let handler = ImageConversionHandler::new(
+        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+        Format::Avif,
+    );
+
+    handler
+        .handle(&DomainEvent::ImageStored {
+            key: "avatars/u1.avif".into(),
+        })
+        .await
+        .unwrap();
+
+    assert!(image_ref.swaps().is_empty());
+}
+
+#[tokio::test]
+async fn skips_already_converted_webp_key() {
+    let storage = in_memory_storage();
+    storage
+        .store("posters/m1.webp", &tiny_jpeg())
+        .await
+        .unwrap();
+    let image_ref = MockImageRef::new();
+    let handler = ImageConversionHandler::new(
+        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+        Format::Webp,
+    );
+
+    handler
+        .handle(&DomainEvent::ImageStored {
+            key: "posters/m1.webp".into(),
+        })
+        .await
+        .unwrap();
+
+    assert!(image_ref.swaps().is_empty());
+}
+
+#[tokio::test]
+async fn converts_jpeg_to_avif_and_swaps_key() {
+    let storage = in_memory_storage();
+    storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
+    let image_ref = MockImageRef::new();
+    let handler = ImageConversionHandler::new(
+        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+        Format::Avif,
+    );
+
+    handler
+        .handle(&DomainEvent::ImageStored {
+            key: "avatars/u1".into(),
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(
+        image_ref.swaps(),
+        vec![("avatars/u1".into(), "avatars/u1.avif".into())]
+    );
+    assert!(storage.get("avatars/u1.avif").await.is_ok());
+}
+
+#[tokio::test]
+async fn converts_jpeg_to_webp_and_swaps_key() {
+    let storage = in_memory_storage();
+    storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
+    let image_ref = MockImageRef::new();
+    let handler = ImageConversionHandler::new(
+        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+        Format::Webp,
+    );
+
+    handler
+        .handle(&DomainEvent::ImageStored {
+            key: "avatars/u1".into(),
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(
+        image_ref.swaps(),
+        vec![("avatars/u1".into(), "avatars/u1.webp".into())]
+    );
+    assert!(storage.get("avatars/u1.webp").await.is_ok());
+}
+
+#[tokio::test]
+async fn image_conversion_is_idempotent_when_run_twice() {
+    for format in [Format::Webp, Format::Avif] {
+        let storage = in_memory_storage();
+        storage.store("posters/m1", &tiny_jpeg()).await.unwrap();
+        let image_ref = MockImageRef::new();
+        let handler = ImageConversionHandler::new(
+            Arc::clone(&storage) as Arc<dyn ObjectStorage>,
+            Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
+            format,
+        );
+        let event = DomainEvent::ImageStored {
+            key: "posters/m1".into(),
+        };
+        let new_key = format!("posters/m1{}", format.extension());
+
+        handler.handle(&event).await.unwrap();
+        let converted = storage.get(&new_key).await.unwrap();
+        handler.handle(&event).await.unwrap();
+
+        assert_eq!(image_ref.swaps().len(), 1, "one swap");
+        assert_eq!(
+            storage.get(&new_key).await.unwrap(),
+            converted,
+            "converted bytes are not re-encoded"
+        );
+    }
+}