test: add new test suite, revamp ratelimit tests

Author: Xevion

src/encode.rs

@@ -14,8 +14,8 @@ fn rasterize_svg_to_rgba(svg_data: &str) -> Result<RgbaImage> {
     let rasterizer = crate::image::Rasterizer::new();
     let pixmap = rasterizer.render(svg_data)?;
 
-    let width = pixmap.width() as u32;
-    let height = pixmap.height() as u32;
+    let width = pixmap.width();
+    let height = pixmap.height();
     let mut img = RgbaImage::new(width, height);
 
     // Copy pixel data from pixmap to image buffer

tests/encode_tests.rs

@@ -0,0 +1,243 @@
+use livecards::encode::{
+    create_encoder, generate_image, AvifEncoder, Encoder, EncoderType, GifEncoder, IcoEncoder,
+    ImageFormat, JpegEncoder, PngEncoder, SvgEncoder, WebPEncoder,
+};
+use std::io::Cursor;
+
+#[tokio::test]
+async fn test_image_format_mime_types() {
+    let test_cases = [
+        (ImageFormat::Png, "image/png"),
+        (ImageFormat::WebP, "image/webp"),
+        (ImageFormat::Jpeg, "image/jpeg"),
+        (ImageFormat::Svg, "image/svg+xml"),
+        (ImageFormat::Avif, "image/avif"),
+        (ImageFormat::Gif, "image/gif"),
+        (ImageFormat::Ico, "image/x-icon"),
+    ];
+
+    for (format, expected_mime) in test_cases {
+        assert_eq!(format.mime_type(), expected_mime);
+    }
+}
+
+#[tokio::test]
+async fn test_image_format_extensions() {
+    let test_cases = [
+        (ImageFormat::Png, "png"),
+        (ImageFormat::WebP, "webp"),
+        (ImageFormat::Jpeg, "jpg"),
+        (ImageFormat::Svg, "svg"),
+        (ImageFormat::Avif, "avif"),
+        (ImageFormat::Gif, "gif"),
+        (ImageFormat::Ico, "ico"),
+    ];
+
+    for (format, expected_ext) in test_cases {
+        assert_eq!(format.extension(), expected_ext);
+    }
+}
+
+#[tokio::test]
+async fn test_encoder_creation() {
+    let test_cases = [
+        (ImageFormat::Png, false),  // Should fail with invalid SVG
+        (ImageFormat::WebP, false), // Should fail with invalid SVG
+        (ImageFormat::Jpeg, false), // Should fail with invalid SVG
+        (ImageFormat::Svg, true),   // Should work for SVG
+        (ImageFormat::Avif, false), // Should fail with invalid SVG
+        (ImageFormat::Gif, false),  // Should fail with invalid SVG
+        (ImageFormat::Ico, false),  // Should fail with invalid SVG
+    ];
+
+    for (format, should_succeed) in test_cases {
+        let encoder = create_encoder(format);
+        let mut cursor = Cursor::new(Vec::new());
+        let result = encoder.encode("test", &mut cursor);
+        assert_eq!(result.is_ok(), should_succeed);
+    }
+}
+
+#[tokio::test]
+async fn test_svg_encoder() {
+    let encoder = SvgEncoder::new();
+    let mut output = Cursor::new(Vec::new());
+    let test_svg = "<svg><text>Hello World</text></svg>";
+
+    let result = encoder.encode(test_svg, &mut output);
+    assert!(result.is_ok());
+
+    let output_data = output.into_inner();
+    assert_eq!(output_data, test_svg.as_bytes());
+}
+
+#[tokio::test]
+async fn test_png_encoder_creation() {
+    let encoder = PngEncoder::new();
+    let mut cursor = Cursor::new(Vec::new());
+    assert!(encoder
+        .encode("<invalid>svg</invalid>", &mut cursor)
+        .is_err());
+}
+
+#[tokio::test]
+async fn test_webp_encoder_creation() {
+    let encoder = WebPEncoder::new();
+    let mut cursor = Cursor::new(Vec::new());
+    assert!(encoder
+        .encode("<invalid>svg</invalid>", &mut cursor)
+        .is_err());
+}
+
+#[tokio::test]
+async fn test_jpeg_encoder_creation() {
+    let encoder = JpegEncoder::new();
+    let mut cursor = Cursor::new(Vec::new());
+    assert!(encoder
+        .encode("<invalid>svg</invalid>", &mut cursor)
+        .is_err());
+}
+
+#[tokio::test]
+async fn test_png_image_generation() {
+    test_single_format_generation(ImageFormat::Png).await;
+}
+
+#[tokio::test]
+async fn test_webp_image_generation() {
+    test_single_format_generation(ImageFormat::WebP).await;
+}
+
+#[tokio::test]
+async fn test_jpeg_image_generation() {
+    test_single_format_generation(ImageFormat::Jpeg).await;
+}
+
+#[tokio::test]
+async fn test_svg_image_generation() {
+    test_single_format_generation(ImageFormat::Svg).await;
+}
+
+#[tokio::test]
+async fn test_avif_image_generation() {
+    test_single_format_generation(ImageFormat::Avif).await;
+}
+
+#[tokio::test]
+async fn test_ico_image_generation() {
+    test_single_format_generation(ImageFormat::Ico).await;
+}
+
+async fn test_single_format_generation(format: ImageFormat) {
+    let test_data = [
+        ("test-repo", "A test repository", "Rust", "42", "7"),
+        (
+            "another-repo",
+            "Another test repository",
+            "Python",
+            "1000",
+            "150",
+        ),
+    ];
+
+    for (name, description, language, stars, forks) in test_data {
+        let mut output = Cursor::new(Vec::new());
+        let result = generate_image(
+            name,
+            description,
+            language,
+            stars,
+            forks,
+            format,
+            &mut output,
+        );
+
+        if let Err(e) = &result {
+            eprintln!("Error generating {:?} image for {}: {:?}", format, name, e);
+        }
+        assert!(
+            result.is_ok(),
+            "Failed to generate {:?} image for {}",
+            format,
+            name
+        );
+
+        let output_data = output.into_inner();
+        assert!(
+            !output_data.is_empty(),
+            "Generated {:?} image is empty for {}",
+            format,
+            name
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_svg_generation_content() {
+    let mut output = Cursor::new(Vec::new());
+    let result = generate_image(
+        "test-repo",
+        "A test repository",
+        "Rust",
+        "42",
+        "7",
+        ImageFormat::Svg,
+        &mut output,
+    );
+
+    assert!(result.is_ok());
+    let output_data = output.into_inner();
+    let svg_content = String::from_utf8_lossy(&output_data);
+
+    // Check that the SVG contains the expected content
+    assert!(svg_content.contains("test-repo"));
+    assert!(svg_content.contains("A test repository"));
+    assert!(svg_content.contains("Rust"));
+    assert!(svg_content.contains("42"));
+    assert!(svg_content.contains("7"));
+    assert!(svg_content.contains("<svg"));
+}
+
+#[tokio::test]
+async fn test_png_error_handling() {
+    test_single_encoder_error_handling(EncoderType::Png(PngEncoder::new()), "PNG").await;
+}
+
+#[tokio::test]
+async fn test_webp_error_handling() {
+    test_single_encoder_error_handling(EncoderType::WebP(WebPEncoder::new()), "WebP").await;
+}
+
+#[tokio::test]
+async fn test_jpeg_error_handling() {
+    test_single_encoder_error_handling(EncoderType::Jpeg(JpegEncoder::new()), "JPEG").await;
+}
+
+#[tokio::test]
+async fn test_avif_error_handling() {
+    test_single_encoder_error_handling(EncoderType::Avif(AvifEncoder::new()), "AVIF").await;
+}
+
+#[tokio::test]
+async fn test_gif_error_handling() {
+    test_single_encoder_error_handling(EncoderType::Gif(GifEncoder::new()), "GIF").await;
+}
+
+#[tokio::test]
+async fn test_ico_error_handling() {
+    test_single_encoder_error_handling(EncoderType::Ico(IcoEncoder::new()), "ICO").await;
+}
+
+async fn test_single_encoder_error_handling(encoder: EncoderType, name: &str) {
+    let mut output = Cursor::new(Vec::new());
+    let result = encoder.encode("<invalid>svg</invalid>", &mut output);
+
+    assert!(
+        result.is_err(),
+        "{} encoder should fail with invalid SVG",
+        name
+    );
+
+    let error = result.unwrap_err();
+    assert!(format!("{:?}", error).contains("Image"));
+}

tests/github_tests.rs

@@ -0,0 +1,113 @@
+use livecards::errors::GitHubError;
+use livecards::github::{CacheEntry, Repository};
+
+// Test fixtures
+fn create_test_repository() -> Repository {
+    Repository {
+        name: "test-repo".to_string(),
+        description: Some("A test repository".to_string()),
+        language: Some("Rust".to_string()),
+        stargazers_count: 42,
+        forks_count: 7,
+    }
+}
+
+fn create_test_repository_json() -> String {
+    r#"{
+        "name": "test-repo",
+        "description": "A test repository",
+        "language": "Rust",
+        "stargazers_count": 42,
+        "forks_count": 7
+    }"#
+    .to_string()
+}
+
+#[tokio::test]
+async fn test_repository_deserialization() {
+    let json = create_test_repository_json();
+    let repo: Repository = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(repo.name, "test-repo");
+    assert_eq!(repo.description, Some("A test repository".to_string()));
+    assert_eq!(repo.language, Some("Rust".to_string()));
+    assert_eq!(repo.stargazers_count, 42);
+    assert_eq!(repo.forks_count, 7);
+}
+
+#[tokio::test]
+async fn test_repository_with_null_fields() {
+    let json = r#"{
+        "name": "test-repo",
+        "description": null,
+        "language": null,
+        "stargazers_count": 0,
+        "forks_count": 0
+    }"#;
+
+    let repo: Repository = serde_json::from_str(json).unwrap();
+
+    assert_eq!(repo.name, "test-repo");
+    assert_eq!(repo.description, None);
+    assert_eq!(repo.language, None);
+    assert_eq!(repo.stargazers_count, 0);
+    assert_eq!(repo.forks_count, 0);
+}
+
+#[tokio::test]
+async fn test_cache_entry_valid() {
+    let repo = create_test_repository();
+    let cache_entry = CacheEntry::Valid(repo.clone());
+
+    match cache_entry {
+        CacheEntry::Valid(cached_repo) => {
+            assert_eq!(cached_repo.name, repo.name);
+            assert_eq!(cached_repo.description, repo.description);
+            assert_eq!(cached_repo.language, repo.language);
+            assert_eq!(cached_repo.stargazers_count, repo.stargazers_count);
+            assert_eq!(cached_repo.forks_count, repo.forks_count);
+        }
+        CacheEntry::Invalid(_, _) => panic!("Expected Valid cache entry"),
+    }
+}
+
+#[tokio::test]
+async fn test_cache_entry_invalid() {
+    let error = GitHubError::NotFound;
+    let retry_count = 2;
+    let cache_entry = CacheEntry::Invalid(error.clone(), retry_count);
+
+    match cache_entry {
+        CacheEntry::Valid(_) => panic!("Expected Invalid cache entry"),
+        CacheEntry::Invalid(cached_error, count) => {
+            assert!(matches!(cached_error, GitHubError::NotFound));
+            assert_eq!(count, retry_count);
+        }
+    }
+}
+
+// Test error handling scenarios
+#[tokio::test]
+async fn test_github_error_variants() {
+    let test_cases = [
+        (GitHubError::NotFound, "Repository not found"),
+        (GitHubError::RateLimited, "GitHub API rate limit exceeded"),
+        (GitHubError::ApiError(500), "GitHub API error: 500"),
+        (
+            GitHubError::NetworkError,
+            "Network error while contacting GitHub API",
+        ),
+        (
+            GitHubError::InvalidFormat("invalid/repo/format".to_string()),
+            "Invalid repository format: invalid/repo/format",
+        ),
+        (
+            GitHubError::AuthError("Invalid token".to_string()),
+            "Authentication failed: Invalid token",
+        ),
+    ];
+
+    for (error, expected_message) in test_cases {
+        assert_eq!(error.to_string(), expected_message);
+    }
+}

tests/image_tests.rs

@@ -0,0 +1,12 @@
+use livecards::colors::get_color;
+
+#[tokio::test]
+async fn test_color_mapping() {
+    // Test known language colors
+    assert_eq!(get_color("Rust"), Some("#dea584".to_string()));
+    assert_eq!(get_color("JavaScript"), Some("#f1e05a".to_string()));
+    assert_eq!(get_color("Python"), Some("#3572A5".to_string()));
+
+    // Test unknown language returns None
+    assert_eq!(get_color("UnknownLanguage"), None);
+}