test: add comprehensive test coverage for render-text-as-image and related components

- **Add blend module tests** for alpha blending edge cases:
  - `both_fully_transparent_stays_transparent()` verifies that blending two fully transparent colors yields transparency
  - `semi_transparent_blend()` ensures semi‑transparent white over black produces mid‑grey

- **Expand render‑text‑as‑image crate tests** to validate public API, defaults, and error handling:
  - Custom foreground/background colour rendering
  - Zero‑padding layout
  - `Rgba` default and constant values (`WHITE`, `BLACK`)
  - `RenderParams` default values match specification
  - `RenderError` Display implementation and `std::error` conformance
  - Debug formatting for error variants

- **Add UI proxy error‑image mapping tests** that verify each cache‑image error variant produces a valid PNG:
  - `UrlIsUnreachable`, `UrlIsNotAnImage`, `ImageTooBig`, `UserQuotaMet`, `Unauthenticated`
  - Ensures `LazyLock` caching produces identical images across calls

- **Include mailer filter test** for `do_nothing_filter` that passes JSON strings unchanged

These tests follow the project's crate‑level test convention (`src/tests/`) and ensure the recently introduced `render‑text‑as‑image` package and its integration points behave correctly across a range of inputs and edge cases.

Author: da2ce7

packages/render-text-as-image/src/blend.rs

@@ -53,4 +53,20 @@ mod tests {
         blend_source_over(&mut dst, [200, 200, 200, 255], 0);
         assert_eq!(dst, original);
     }
+
+    #[test]
+    fn both_fully_transparent_stays_transparent() {
+        let mut dst = Rgba([0, 0, 0, 0]);
+        blend_source_over(&mut dst, [255, 255, 255, 0], 0);
+        assert_eq!(dst, Rgba([0, 0, 0, 0]));
+    }
+
+    #[test]
+    fn semi_transparent_blend() {
+        let mut dst = Rgba([0, 0, 0, 255]);
+        blend_source_over(&mut dst, [255, 255, 255, 255], 128);
+        // After blending, the pixel should be a mid-grey.
+        assert!(dst.0[0] > 100 && dst.0[0] < 200);
+        assert_eq!(dst.0[3], 255);
+    }
 }

packages/render-text-as-image/src/tests/mod.rs

@@ -1,7 +1,9 @@
 //! Crate-level tests for the public API.
 
 use crate::types::MAX_TEXT_BYTES;
-use crate::{render_text_to_png, RenderError, RenderParams};
+use crate::{render_text_to_png, RenderError, RenderParams, Rgba};
+
+// --- Rendering tests ---
 
 #[test]
 fn empty_text_produces_valid_png() {
@@ -44,3 +46,82 @@ fn deterministic_output() {
     let b = render_text_to_png(&params).unwrap();
     assert_eq!(a, b);
 }
+
+#[test]
+fn custom_colours_produce_valid_png() {
+    let params = RenderParams {
+        text: "colour",
+        fg_colour: Rgba::BLACK,
+        bg_colour: Rgba::WHITE,
+        ..Default::default()
+    };
+    let png = render_text_to_png(&params).unwrap();
+    assert_eq!(&png[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn zero_padding_produces_valid_png() {
+    let params = RenderParams {
+        text: "tight",
+        padding_em: 0.0,
+        ..Default::default()
+    };
+    let png = render_text_to_png(&params).unwrap();
+    assert_eq!(&png[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+// --- Type default / constant tests ---
+
+#[test]
+fn rgba_default_is_white() {
+    assert_eq!(Rgba::default(), Rgba::WHITE);
+}
+
+#[test]
+fn rgba_white_has_expected_components() {
+    assert_eq!(Rgba::WHITE.0, [255, 255, 255, 255]);
+}
+
+#[test]
+fn rgba_black_has_expected_components() {
+    assert_eq!(Rgba::BLACK.0, [0, 0, 0, 255]);
+}
+
+#[test]
+fn render_params_default_values() {
+    let p = RenderParams::default();
+    assert_eq!(p.text, "");
+    assert!((p.font_size_px - 20.0).abs() < f32::EPSILON);
+    assert_eq!(p.fg_colour, Rgba::WHITE);
+    assert_eq!(p.bg_colour, Rgba([0x33, 0x33, 0x33, 0xFF]));
+    assert!((p.padding_em - 0.4).abs() < f32::EPSILON);
+}
+
+// --- RenderError Display / Error tests ---
+
+#[test]
+fn render_error_text_too_long_display() {
+    let err = RenderError::TextTooLong;
+    let msg = err.to_string();
+    assert!(msg.contains("256"), "should mention the byte limit: {msg}");
+}
+
+#[test]
+fn render_error_encoding_failed_display() {
+    let err = RenderError::EncodingFailed("oops".into());
+    let msg = err.to_string();
+    assert!(msg.contains("oops"), "should contain the inner message: {msg}");
+}
+
+#[test]
+fn render_error_implements_std_error() {
+    let err = RenderError::TextTooLong;
+    let _: &dyn std::error::Error = &err;
+}
+
+#[test]
+fn render_error_debug_format() {
+    let err = RenderError::TextTooLong;
+    let dbg = format!("{err:?}");
+    assert!(dbg.contains("TextTooLong"));
+}

src/tests/mailer.rs

@@ -1,6 +1,7 @@
 use lettre::Message;
+use serde_json::json;
 
-use crate::mailer::{build_content, build_letter};
+use crate::mailer::{build_content, build_letter, do_nothing_filter};
 
 #[test]
 fn it_should_build_a_letter() {
@@ -18,3 +19,11 @@ fn it_should_build_content() {
     assert_ne!(plain_body, "");
     assert_ne!(html_body, "");
 }
+
+#[test]
+fn do_nothing_filter_passes_through_string() {
+    let input = json!("hello world");
+    let args = std::collections::HashMap::new();
+    let result = do_nothing_filter(&input, &args).unwrap();
+    assert_eq!(result, json!("hello world"));
+}

src/tests/mod.rs

@@ -5,4 +5,5 @@ mod mailer;
 mod models;
 mod services;
 mod tracker;
+mod ui;
 mod utils;

src/tests/ui/mod.rs

@@ -0,0 +1 @@
+mod proxy;

src/tests/ui/proxy.rs

@@ -0,0 +1,39 @@
+use crate::cache::image::manager::Error;
+use crate::ui::proxy::map_error_to_image;
+
+#[test]
+fn map_error_url_is_unreachable() {
+    let img = map_error_to_image(&Error::UrlIsUnreachable);
+    assert_eq!(&img[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn map_error_url_is_not_an_image() {
+    let img = map_error_to_image(&Error::UrlIsNotAnImage);
+    assert_eq!(&img[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn map_error_image_too_big() {
+    let img = map_error_to_image(&Error::ImageTooBig);
+    assert_eq!(&img[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn map_error_user_quota_met() {
+    let img = map_error_to_image(&Error::UserQuotaMet);
+    assert_eq!(&img[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn map_error_unauthenticated() {
+    let img = map_error_to_image(&Error::Unauthenticated);
+    assert_eq!(&img[..4], &[0x89, b'P', b'N', b'G']);
+}
+
+#[test]
+fn cached_images_are_consistent() {
+    let a = map_error_to_image(&Error::UrlIsUnreachable);
+    let b = map_error_to_image(&Error::UrlIsUnreachable);
+    assert_eq!(a, b, "LazyLock-cached images should be identical across calls");
+}