fmt

tests/basic_test.rs

@@ -1,4 +1,4 @@
-use actix_web::{test, web, App, HttpResponse};
+use actix_web::{App, HttpResponse, test, web};
 
 /// Простой тест health check
 #[actix_web::test]
@@ -329,25 +329,37 @@ async fn test_thumbnail_path_parsing() {
         if path.is_empty() {
             return ("".to_string(), 0, "".to_string());
         }
-        
+
         // Ищем последний underscore перед расширением
         let dot_pos = path.rfind('.');
-        let name_part = if let Some(pos) = dot_pos { &path[..pos] } else { path };
-        
+        let name_part = if let Some(pos) = dot_pos {
+            &path[..pos]
+        } else {
+            path
+        };
+
         // Ищем underscore для ширины
         if let Some(underscore_pos) = name_part.rfind('_') {
             let base = name_part[..underscore_pos].to_string();
             let width_part = &name_part[underscore_pos + 1..];
-            
+
             if let Ok(width) = width_part.parse::<u32>() {
-                let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+                let ext = if let Some(pos) = dot_pos {
+                    path[pos + 1..].to_string()
+                } else {
+                    "".to_string()
+                };
                 return (base, width, ext);
             }
         }
-        
+
         // Если не нашли ширину, возвращаем как есть
         let base = name_part.to_string();
-        let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+        let ext = if let Some(pos) = dot_pos {
+            path[pos + 1..].to_string()
+        } else {
+            "".to_string()
+        };
         (base, 0, ext)
     }
 
@@ -356,7 +368,10 @@ async fn test_thumbnail_path_parsing() {
         ("image_300.jpg", ("image", 300, "jpg")),
         ("photo_800.png", ("photo", 800, "png")),
         ("document.pdf", ("document", 0, "pdf")),
-        ("file_with_underscore_but_no_width.gif", ("file_with_underscore_but_no_width", 0, "gif")),
+        (
+            "file_with_underscore_but_no_width.gif",
+            ("file_with_underscore_but_no_width", 0, "gif"),
+        ),
         ("unsafe_1920x.jpg", ("unsafe_1920x", 0, "jpg")),
         ("unsafe_1920x.png", ("unsafe_1920x", 0, "png")),
         ("unsafe_1920x", ("unsafe_1920x", 0, "")),
@@ -386,7 +401,7 @@ async fn test_image_format_detection() {
             "gif" => Ok(image::ImageFormat::Gif),
             "webp" => Ok(image::ImageFormat::WebP),
             "heic" | "heif" | "tiff" | "tif" => Ok(image::ImageFormat::Jpeg),
-            _ => Err(())
+            _ => Err(()),
         }
     }
     use image::ImageFormat;
@@ -430,14 +445,14 @@ async fn test_find_closest_width() {
     // Мокаем функцию find_closest_width для тестов
     fn find_closest_width(requested: u32) -> u32 {
         let available_widths = vec![100, 150, 200, 300, 400, 500, 600, 800];
-        
+
         if available_widths.contains(&requested) {
             return requested;
         }
-        
+
         let mut closest = available_widths[0];
         let mut min_diff = (requested as i32 - closest as i32).abs();
-        
+
         for &width in &available_widths[1..] {
             let diff = (requested as i32 - width as i32).abs();
             if diff < min_diff {
@@ -445,28 +460,28 @@ async fn test_find_closest_width() {
                 closest = width;
             }
         }
-        
+
         closest
     }
 
     let test_cases = vec![
-        (100, 100),   // Точное совпадение
-        (150, 150),   // Точное совпадение
-        (200, 200),   // Точное совпадение
-        (300, 300),   // Точное совпадение
-        (400, 400),   // Точное совпадение
-        (500, 500),   // Точное совпадение
-        (600, 600),   // Точное совпадение
-        (800, 800),   // Точное совпадение
-        (120, 100),   // Ближайшее к 100 (разница 20)
-        (180, 200),   // Ближайшее к 200 (разница 20)
-        (250, 200),   // Ближайшее к 200 (разница 50)
-        (350, 300),   // Ближайшее к 300 (разница 50)
-        (450, 400),   // Ближайшее к 400 (разница 50)
-        (550, 500),   // Ближайшее к 500 (разница 50)
-        (700, 600),   // Ближайшее к 600 (разница 100)
-        (1000, 800),  // Больше максимального - возвращаем максимальный
-        (2000, 800),  // Больше максимального - возвращаем максимальный
+        (100, 100),  // Точное совпадение
+        (150, 150),  // Точное совпадение
+        (200, 200),  // Точное совпадение
+        (300, 300),  // Точное совпадение
+        (400, 400),  // Точное совпадение
+        (500, 500),  // Точное совпадение
+        (600, 600),  // Точное совпадение
+        (800, 800),  // Точное совпадение
+        (120, 100),  // Ближайшее к 100 (разница 20)
+        (180, 200),  // Ближайшее к 200 (разница 20)
+        (250, 200),  // Ближайшее к 200 (разница 50)
+        (350, 300),  // Ближайшее к 300 (разница 50)
+        (450, 400),  // Ближайшее к 400 (разница 50)
+        (550, 500),  // Ближайшее к 500 (разница 50)
+        (700, 600),  // Ближайшее к 600 (разница 100)
+        (1000, 800), // Больше максимального - возвращаем максимальный
+        (2000, 800), // Больше максимального - возвращаем максимальный
     ];
 
     for (requested, expected) in test_cases {
@@ -490,10 +505,10 @@ async fn test_lookup_functions() {
             "gif" => Some("image/gif"),
             "webp" => Some("image/webp"),
             "mp4" => Some("video/mp4"),
-            _ => None
+            _ => None,
         }
     }
-    
+
     fn find_file_by_pattern(_pattern: &str) -> Option<String> {
         Some("test_file.jpg".to_string())
     }
@@ -531,12 +546,18 @@ async fn test_s3_utils_functions() {
     async fn get_s3_filelist(_bucket: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
         Ok(vec!["file1.jpg".to_string(), "file2.png".to_string()])
     }
-    
-    async fn check_file_exists(_bucket: &str, _key: &str) -> Result<bool, Box<dyn std::error::Error>> {
+
+    async fn check_file_exists(
+        _bucket: &str,
+        _key: &str,
+    ) -> Result<bool, Box<dyn std::error::Error>> {
         Ok(true)
     }
-    
-    async fn load_file_from_s3(_bucket: &str, _key: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
+
+    async fn load_file_from_s3(
+        _bucket: &str,
+        _key: &str,
+    ) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
         Ok(b"fake file content".to_vec())
     }
 
@@ -549,15 +570,18 @@ async fn test_s3_utils_functions() {
 #[test]
 async fn test_overlay_functions() {
     // Мокаем функцию generate_overlay для тестов
-    async fn generate_overlay(shout_id: &str, image_data: actix_web::web::Bytes) -> Result<actix_web::web::Bytes, Box<dyn std::error::Error>> {
+    async fn generate_overlay(
+        shout_id: &str,
+        image_data: actix_web::web::Bytes,
+    ) -> Result<actix_web::web::Bytes, Box<dyn std::error::Error>> {
         if image_data.is_empty() {
             return Err("Empty image data".into());
         }
-        
+
         if shout_id == "invalid_id" {
             return Ok(image_data);
         }
-        
+
         Ok(image_data)
     }
     use actix_web::web::Bytes;
@@ -565,16 +589,19 @@ async fn test_overlay_functions() {
     // Тестируем с пустыми данными
     let empty_bytes = Bytes::from(vec![]);
     let result = generate_overlay("123", empty_bytes).await;
-    
+
     // Должен вернуть ошибку при попытке загрузить изображение из пустых данных
     assert!(result.is_err(), "Should fail with empty image data");
 
     // Тестируем с некорректным shout_id
     let test_bytes = Bytes::from(b"fake image data".to_vec());
     let result = generate_overlay("invalid_id", test_bytes).await;
-    
+
     // Должен вернуть оригинальные данные при ошибке получения shout
-    assert!(result.is_ok(), "Should return original data when shout fetch fails");
+    assert!(
+        result.is_ok(),
+        "Should return original data when shout fetch fails"
+    );
 }
 
 /// Тест для проверки функций core.rs
@@ -607,8 +634,11 @@ async fn test_auth_functions() {
         }
         Ok(123)
     }
-    
-    async fn user_added_file(_user_id: u32, _filename: &str) -> Result<(), Box<dyn std::error::Error>> {
+
+    async fn user_added_file(
+        _user_id: u32,
+        _filename: &str,
+    ) -> Result<(), Box<dyn std::error::Error>> {
         Ok(())
     }
 
@@ -644,23 +674,23 @@ async fn test_handlers_functions() {
     async fn get_quota_handler() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().json(serde_json::json!({"quota": 1024}))
     }
-    
+
     async fn increase_quota_handler() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "increased"}))
     }
-    
+
     async fn set_quota_handler() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "set"}))
     }
-    
+
     async fn proxy_handler() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().body("proxy response")
     }
-    
+
     async fn serve_file() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().body("file content")
     }
-    
+
     async fn upload_handler() -> actix_web::HttpResponse {
         actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "uploaded"}))
     }
@@ -679,35 +709,47 @@ async fn test_integration() {
         if path.is_empty() {
             return ("".to_string(), 0, "".to_string());
         }
-        
+
         // Ищем последний underscore перед расширением
         let dot_pos = path.rfind('.');
-        let name_part = if let Some(pos) = dot_pos { &path[..pos] } else { path };
-        
+        let name_part = if let Some(pos) = dot_pos {
+            &path[..pos]
+        } else {
+            path
+        };
+
         // Ищем underscore для ширины
         if let Some(underscore_pos) = name_part.rfind('_') {
             let base = name_part[..underscore_pos].to_string();
             let width_part = &name_part[underscore_pos + 1..];
-            
+
             if let Ok(width) = width_part.parse::<u32>() {
-                let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+                let ext = if let Some(pos) = dot_pos {
+                    path[pos + 1..].to_string()
+                } else {
+                    "".to_string()
+                };
                 return (base, width, ext);
             }
         }
-        
+
         // Если не нашли ширину, возвращаем как есть
         let base = name_part.to_string();
-        let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+        let ext = if let Some(pos) = dot_pos {
+            path[pos + 1..].to_string()
+        } else {
+            "".to_string()
+        };
         (base, 0, ext)
     }
-    
+
     fn get_mime_type(ext: &str) -> Option<&'static str> {
         match ext.to_lowercase().as_str() {
             "jpg" | "jpeg" => Some("image/jpeg"),
             "png" => Some("image/png"),
             "gif" => Some("image/gif"),
             "webp" => Some("image/webp"),
-            _ => None
+            _ => None,
         }
     }
 
@@ -729,32 +771,44 @@ async fn test_edge_cases() {
         if path.is_empty() {
             return ("".to_string(), 0, "".to_string());
         }
-        
+
         if path == "." || path == ".." {
             return (path.to_string(), 0, "".to_string());
         }
-        
+
         // Ищем последний underscore перед расширением
         let dot_pos = path.rfind('.');
-        let name_part = if let Some(pos) = dot_pos { &path[..pos] } else { path };
-        
+        let name_part = if let Some(pos) = dot_pos {
+            &path[..pos]
+        } else {
+            path
+        };
+
         // Ищем underscore для ширины
         if let Some(underscore_pos) = name_part.rfind('_') {
             let base = name_part[..underscore_pos].to_string();
             let width_part = &name_part[underscore_pos + 1..];
-            
+
             if let Ok(width) = width_part.parse::<u32>() {
-                let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+                let ext = if let Some(pos) = dot_pos {
+                    path[pos + 1..].to_string()
+                } else {
+                    "".to_string()
+                };
                 return (base, width, ext);
             }
         }
-        
+
         // Если не нашли ширину, возвращаем как есть
         let base = name_part.to_string();
-        let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+        let ext = if let Some(pos) = dot_pos {
+            path[pos + 1..].to_string()
+        } else {
+            "".to_string()
+        };
         (base, 0, ext)
     }
-    
+
     // Тестируем пустые строки
     assert_eq!(parse_file_path(""), ("".to_string(), 0, "".to_string()));
     assert_eq!(parse_file_path("."), (".".to_string(), 0, "".to_string()));
@@ -779,31 +833,43 @@ async fn test_edge_cases() {
 #[test]
 async fn test_parsing_performance() {
     use std::time::Instant;
-    
+
     // Мокаем функцию parse_file_path для теста производительности
     fn parse_file_path(path: &str) -> (String, u32, String) {
         if path.is_empty() {
             return ("".to_string(), 0, "".to_string());
         }
-        
+
         // Ищем последний underscore перед расширением
         let dot_pos = path.rfind('.');
-        let name_part = if let Some(pos) = dot_pos { &path[..pos] } else { path };
-        
+        let name_part = if let Some(pos) = dot_pos {
+            &path[..pos]
+        } else {
+            path
+        };
+
         // Ищем underscore для ширины
         if let Some(underscore_pos) = name_part.rfind('_') {
             let base = name_part[..underscore_pos].to_string();
             let width_part = &name_part[underscore_pos + 1..];
-            
+
             if let Ok(width) = width_part.parse::<u32>() {
-                let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+                let ext = if let Some(pos) = dot_pos {
+                    path[pos + 1..].to_string()
+                } else {
+                    "".to_string()
+                };
                 return (base, width, ext);
             }
         }
-        
+
         // Если не нашли ширину, возвращаем как есть
         let base = name_part.to_string();
-        let ext = if let Some(pos) = dot_pos { path[pos + 1..].to_string() } else { "".to_string() };
+        let ext = if let Some(pos) = dot_pos {
+            path[pos + 1..].to_string()
+        } else {
+            "".to_string()
+        };
         (base, 0, ext)
     }