Untone
86ad1f1695
Some checks failed
Deploy quoter Microservice on push / deploy (push) Failing after 36m41s
### 🔒 FIX: JWT Token Grace Period - **✅ Добавлен grace period для истекших токенов**: 60 секунд - Изменена логика проверки JWT `exp` в `auth.rs` - Токены принимаются в течение 60 секунд после истечения - Это даёт клиенту время автоматически обновить токен через `refreshToken()` - Логирование разделено: `info` для grace period, `warn` для полного истечения - Решает проблему "Invalid or expired token" при параллельных запросах - Формула: `if exp + 60 < current_time` → reject, иначе accept - Предотвращает race condition: upload начался до истечения, закончился после
787 lines
27 KiB
Rust
787 lines
27 KiB
Rust
// Tests use direct assertions without actix_web framework
|
||
|
||
/// Тест для проверки JSON сериализации/десериализации
|
||
#[tokio::test]
|
||
async fn test_json_serialization() {
|
||
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug)]
|
||
struct TestStruct {
|
||
user_id: String,
|
||
current_quota: u64,
|
||
max_quota: u64,
|
||
}
|
||
|
||
let test_data = TestStruct {
|
||
user_id: "test-user-123".to_string(),
|
||
current_quota: 1024,
|
||
max_quota: 5368709120, // 5 GB
|
||
};
|
||
|
||
// Сериализация
|
||
let json_string = serde_json::to_string(&test_data).unwrap();
|
||
assert!(json_string.contains("test-user-123"));
|
||
assert!(json_string.contains("1024"));
|
||
assert!(json_string.contains("5368709120"));
|
||
|
||
// Десериализация
|
||
let deserialized: TestStruct = serde_json::from_str(&json_string).unwrap();
|
||
assert_eq!(deserialized, test_data);
|
||
}
|
||
|
||
/// Тест для проверки multipart form data
|
||
#[tokio::test]
|
||
async fn test_multipart_form_data() {
|
||
let boundary = "test-boundary";
|
||
let filename = "test.png";
|
||
let content = b"fake image data";
|
||
|
||
let mut form_data = Vec::new();
|
||
|
||
// Начало multipart
|
||
form_data.extend_from_slice(format!("--{}\r\n", boundary).as_bytes());
|
||
form_data.extend_from_slice(
|
||
format!(
|
||
"Content-Disposition: form-data; name=\"file\"; filename=\"{}\"\r\n",
|
||
filename
|
||
)
|
||
.as_bytes(),
|
||
);
|
||
form_data.extend_from_slice(b"Content-Type: image/png\r\n\r\n");
|
||
|
||
// Содержимое файла
|
||
form_data.extend_from_slice(content);
|
||
form_data.extend_from_slice(b"\r\n");
|
||
|
||
// Конец multipart
|
||
form_data.extend_from_slice(format!("--{}--\r\n", boundary).as_bytes());
|
||
|
||
// Проверяем, что form_data содержит ожидаемые части
|
||
let form_data_str = String::from_utf8_lossy(&form_data);
|
||
assert!(form_data_str.contains(filename));
|
||
assert!(form_data_str.contains("image/png"));
|
||
assert!(form_data_str.contains("fake image data"));
|
||
assert!(form_data_str.contains(&format!("--{}", boundary)));
|
||
}
|
||
|
||
/// Тест для проверки UUID генерации
|
||
#[tokio::test]
|
||
async fn test_uuid_generation() {
|
||
use uuid::Uuid;
|
||
|
||
let uuid1 = Uuid::new_v4();
|
||
let uuid2 = Uuid::new_v4();
|
||
|
||
// UUID должны быть разными
|
||
assert_ne!(uuid1, uuid2);
|
||
|
||
// UUID должны быть в правильном формате
|
||
let uuid_str = uuid1.to_string();
|
||
assert_eq!(uuid_str.len(), 36); // 32 символа + 4 дефиса
|
||
assert!(uuid_str.contains('-'));
|
||
|
||
// Проверяем, что UUID можно парсить обратно
|
||
let parsed_uuid = Uuid::parse_str(&uuid_str).unwrap();
|
||
assert_eq!(parsed_uuid, uuid1);
|
||
}
|
||
|
||
/// Тест для проверки MIME типов
|
||
#[tokio::test]
|
||
async fn test_mime_type_detection() {
|
||
// Тестируем определение MIME типа по расширению
|
||
let 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"),
|
||
"mp3" => Some("audio/mpeg"),
|
||
"wav" => Some("audio/wav"),
|
||
"mp4" => Some("video/mp4"),
|
||
_ => None,
|
||
}
|
||
};
|
||
|
||
assert_eq!(get_mime_type("jpg"), Some("image/jpeg"));
|
||
assert_eq!(get_mime_type("jpeg"), Some("image/jpeg"));
|
||
assert_eq!(get_mime_type("png"), Some("image/png"));
|
||
assert_eq!(get_mime_type("gif"), Some("image/gif"));
|
||
assert_eq!(get_mime_type("webp"), Some("image/webp"));
|
||
assert_eq!(get_mime_type("mp3"), Some("audio/mpeg"));
|
||
assert_eq!(get_mime_type("wav"), Some("audio/wav"));
|
||
assert_eq!(get_mime_type("mp4"), Some("video/mp4"));
|
||
assert_eq!(get_mime_type("pdf"), None);
|
||
assert_eq!(get_mime_type(""), None);
|
||
}
|
||
|
||
/// Тест для проверки парсинга путей файлов
|
||
#[tokio::test]
|
||
async fn test_file_path_parsing() {
|
||
fn parse_file_path(path: &str) -> (String, u32, String) {
|
||
let parts: Vec<&str> = path.split('.').collect();
|
||
if parts.len() != 2 {
|
||
return (path.to_string(), 0, "".to_string());
|
||
}
|
||
|
||
let base_with_width = parts[0];
|
||
let ext = parts[1];
|
||
|
||
// Ищем ширину в формате _NUMBER
|
||
let base_parts: Vec<&str> = base_with_width.split('_').collect();
|
||
if base_parts.len() >= 2 {
|
||
if let Ok(width) = base_parts.last().unwrap().parse::<u32>() {
|
||
let base = base_parts[..base_parts.len() - 1].join("_");
|
||
return (base, width, ext.to_string());
|
||
}
|
||
}
|
||
|
||
(base_with_width.to_string(), 0, ext.to_string())
|
||
}
|
||
|
||
let (base, width, ext) = parse_file_path("image_300.jpg");
|
||
assert_eq!(base, "image");
|
||
assert_eq!(width, 300);
|
||
assert_eq!(ext, "jpg");
|
||
|
||
let (base, width, ext) = parse_file_path("document.pdf");
|
||
assert_eq!(base, "document");
|
||
assert_eq!(width, 0);
|
||
assert_eq!(ext, "pdf");
|
||
|
||
let (base, width, ext) = parse_file_path("file_with_underscore_but_no_width.jpg");
|
||
assert_eq!(base, "file_with_underscore_but_no_width");
|
||
assert_eq!(width, 0);
|
||
assert_eq!(ext, "jpg");
|
||
}
|
||
|
||
/// Тест для проверки расчетов квот
|
||
#[tokio::test]
|
||
async fn test_quota_calculations() {
|
||
const MAX_QUOTA_BYTES: u64 = 5 * 1024 * 1024 * 1024; // 5 ГБ
|
||
const MB: u64 = 1024 * 1024;
|
||
const GB: u64 = 1024 * 1024 * 1024;
|
||
|
||
// Тестируем различные сценарии
|
||
let test_cases = vec![
|
||
(0, MB, true), // Пустая квота + 1MB = OK
|
||
(GB, MB, true), // 1GB + 1MB = OK
|
||
(4 * GB, GB, true), // 4GB + 1GB = OK
|
||
(4 * GB, 2 * GB, false), // 4GB + 2GB = превышение
|
||
(5 * GB, MB, false), // 5GB + 1MB = превышение
|
||
];
|
||
|
||
for (current_quota, file_size, should_allow) in test_cases {
|
||
let would_exceed = current_quota + file_size > MAX_QUOTA_BYTES;
|
||
assert_eq!(
|
||
would_exceed,
|
||
!should_allow,
|
||
"Квота: {} + файл: {} = {}, должно быть разрешено: {}",
|
||
current_quota,
|
||
file_size,
|
||
current_quota + file_size,
|
||
should_allow
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Тест для проверки форматирования размеров файлов
|
||
#[tokio::test]
|
||
async fn test_file_size_formatting() {
|
||
fn format_file_size(bytes: u64) -> String {
|
||
const KB: u64 = 1024;
|
||
const MB: u64 = 1024 * 1024;
|
||
const GB: u64 = 1024 * 1024 * 1024;
|
||
|
||
match bytes {
|
||
0..KB => format!("{} B", bytes),
|
||
KB..MB => format!("{:.1} KB", bytes as f64 / KB as f64),
|
||
MB..GB => format!("{:.1} MB", bytes as f64 / MB as f64),
|
||
_ => format!("{:.1} GB", bytes as f64 / GB as f64),
|
||
}
|
||
}
|
||
|
||
assert_eq!(format_file_size(512), "512 B");
|
||
assert_eq!(format_file_size(1024), "1.0 KB");
|
||
assert_eq!(format_file_size(1536), "1.5 KB");
|
||
assert_eq!(format_file_size(1024 * 1024), "1.0 MB");
|
||
assert_eq!(format_file_size(1024 * 1024 * 1024), "1.0 GB");
|
||
assert_eq!(format_file_size(5 * 1024 * 1024 * 1024), "5.0 GB");
|
||
}
|
||
|
||
/// Тест для проверки обработки ошибок
|
||
#[tokio::test]
|
||
async fn test_error_handling() {
|
||
// Тестируем парсинг неверного JSON
|
||
let invalid_json = "{ invalid json }";
|
||
let result: Result<serde_json::Value, _> = serde_json::from_str(invalid_json);
|
||
assert!(result.is_err());
|
||
|
||
// Тестируем парсинг неполного JSON
|
||
let incomplete_json = r#"{"user_id": "test"#;
|
||
let result: Result<serde_json::Value, _> = serde_json::from_str(incomplete_json);
|
||
assert!(result.is_err());
|
||
|
||
// Тестируем неверный UUID
|
||
use uuid::Uuid;
|
||
let invalid_uuid = "not-a-uuid";
|
||
let result = Uuid::parse_str(invalid_uuid);
|
||
assert!(result.is_err());
|
||
|
||
// Тестируем пустой UUID
|
||
let empty_uuid = "";
|
||
let result = Uuid::parse_str(empty_uuid);
|
||
assert!(result.is_err());
|
||
}
|
||
|
||
/// Тест для проверки производительности
|
||
#[tokio::test]
|
||
async fn test_performance() {
|
||
use std::time::Instant;
|
||
|
||
// Тест UUID генерации
|
||
let start = Instant::now();
|
||
let iterations = 10000;
|
||
|
||
for _ in 0..iterations {
|
||
let _uuid = uuid::Uuid::new_v4();
|
||
}
|
||
|
||
let duration = start.elapsed();
|
||
let avg_time = duration.as_nanos() as f64 / iterations as f64;
|
||
|
||
println!(
|
||
"UUID generation: {} UUIDs in {:?}, avg: {:.2} ns per UUID",
|
||
iterations, duration, avg_time
|
||
);
|
||
|
||
// Проверяем, что среднее время меньше 5μs (реалистичный порог для CI)
|
||
assert!(
|
||
avg_time < 5000.0,
|
||
"UUID generation too slow: {:.2} ns",
|
||
avg_time
|
||
);
|
||
|
||
// Тест JSON сериализации
|
||
let start = Instant::now();
|
||
|
||
for _ in 0..iterations {
|
||
let data = serde_json::json!({
|
||
"user_id": "test-user-123",
|
||
"current_quota": 1024,
|
||
"max_quota": 5368709120u64
|
||
});
|
||
let _json_string = serde_json::to_string(&data).unwrap();
|
||
}
|
||
|
||
let duration = start.elapsed();
|
||
let avg_time = duration.as_micros() as f64 / iterations as f64;
|
||
|
||
println!(
|
||
"JSON serialization: {} operations in {:?}, avg: {:.2} μs per operation",
|
||
iterations, duration, avg_time
|
||
);
|
||
|
||
// Проверяем, что среднее время меньше 100μs
|
||
assert!(
|
||
avg_time < 100.0,
|
||
"JSON serialization too slow: {:.2} μs",
|
||
avg_time
|
||
);
|
||
}
|
||
|
||
/// Тест для проверки функций парсинга путей файлов (thumbnail.rs)
|
||
#[tokio::test]
|
||
async fn test_thumbnail_path_parsing() {
|
||
// Мокаем функцию 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
|
||
};
|
||
|
||
// Ищем 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()
|
||
};
|
||
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()
|
||
};
|
||
(base, 0, ext)
|
||
}
|
||
|
||
// Тестируем различные форматы путей
|
||
let test_cases = vec![
|
||
("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"),
|
||
),
|
||
("unsafe_1920x.jpg", ("unsafe_1920x", 0, "jpg")),
|
||
("unsafe_1920x.png", ("unsafe_1920x", 0, "png")),
|
||
("unsafe_1920x", ("unsafe_1920x", 0, "")),
|
||
("unsafe", ("unsafe", 0, "")),
|
||
("", ("", 0, "")),
|
||
];
|
||
|
||
for (input, expected) in test_cases {
|
||
let (base, width, ext) = parse_file_path(input);
|
||
assert_eq!(
|
||
(base.as_str(), width, ext.as_str()),
|
||
expected,
|
||
"Failed for input: '{}'",
|
||
input
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Тест для проверки определения формата изображения (thumbnail.rs)
|
||
#[tokio::test]
|
||
async fn test_image_format_detection() {
|
||
// Мокаем функцию determine_image_format для тестов
|
||
fn determine_image_format(ext: &str) -> Result<image::ImageFormat, ()> {
|
||
match ext.to_lowercase().as_str() {
|
||
"jpg" | "jpeg" => Ok(image::ImageFormat::Jpeg),
|
||
"png" => Ok(image::ImageFormat::Png),
|
||
"gif" => Ok(image::ImageFormat::Gif),
|
||
"webp" => Ok(image::ImageFormat::WebP),
|
||
"heic" | "heif" | "tiff" | "tif" => Ok(image::ImageFormat::Jpeg),
|
||
_ => Err(()),
|
||
}
|
||
}
|
||
use image::ImageFormat;
|
||
|
||
let test_cases = vec![
|
||
("jpg", Ok(ImageFormat::Jpeg)),
|
||
("jpeg", Ok(ImageFormat::Jpeg)),
|
||
("png", Ok(ImageFormat::Png)),
|
||
("gif", Ok(ImageFormat::Gif)),
|
||
("webp", Ok(ImageFormat::WebP)),
|
||
("heic", Ok(ImageFormat::Jpeg)), // HEIC конвертируется в JPEG
|
||
("heif", Ok(ImageFormat::Jpeg)), // HEIF конвертируется в JPEG
|
||
("tiff", Ok(ImageFormat::Jpeg)), // TIFF конвертируется в JPEG
|
||
("tif", Ok(ImageFormat::Jpeg)), // TIF конвертируется в JPEG
|
||
("pdf", Err(())), // Неподдерживаемый формат
|
||
("", Err(())), // Пустое расширение
|
||
];
|
||
|
||
for (ext, expected) in test_cases {
|
||
let result = determine_image_format(ext);
|
||
match (result, expected) {
|
||
(Ok(format), Ok(expected_format)) => {
|
||
assert_eq!(format, expected_format, "Failed for extension: '{}'", ext);
|
||
}
|
||
(Err(_), Err(_)) => {
|
||
// Оба должны быть ошибками
|
||
}
|
||
_ => {
|
||
panic!(
|
||
"Mismatch for extension '{}': got {:?}, expected {:?}",
|
||
ext, result, expected
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Тест для проверки поиска ближайшей ширины (thumbnail.rs)
|
||
#[tokio::test]
|
||
async fn test_find_closest_width() {
|
||
// Мокаем функцию find_closest_width для тестов
|
||
fn find_closest_width(requested: u32) -> u32 {
|
||
let available_widths = [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 {
|
||
min_diff = diff;
|
||
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), // Больше максимального - возвращаем максимальный
|
||
];
|
||
|
||
for (requested, expected) in test_cases {
|
||
let result = find_closest_width(requested);
|
||
assert_eq!(
|
||
result, expected,
|
||
"Failed for requested width: {}, got: {}, expected: {}",
|
||
requested, result, expected
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Тест для проверки функций lookup.rs
|
||
#[tokio::test]
|
||
async fn test_lookup_functions() {
|
||
// Мокаем функции lookup для тестов
|
||
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"),
|
||
"mp4" => Some("video/mp4"),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
// Тестируем get_mime_type
|
||
let mime_tests = vec![
|
||
("jpg", Some("image/jpeg")),
|
||
("jpeg", Some("image/jpeg")),
|
||
("png", Some("image/png")),
|
||
("gif", Some("image/gif")),
|
||
("webp", Some("image/webp")),
|
||
("mp4", Some("video/mp4")),
|
||
("pdf", None),
|
||
("", None),
|
||
];
|
||
|
||
for (ext, expected) in mime_tests {
|
||
let result = get_mime_type(ext);
|
||
assert_eq!(
|
||
result, expected,
|
||
"Failed for extension: '{}', got: {:?}, expected: {:?}",
|
||
ext, result, expected
|
||
);
|
||
}
|
||
}
|
||
|
||
// S3 utils tests removed - mock functions not actually used
|
||
|
||
/// Тест для проверки функций overlay.rs
|
||
#[tokio::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>> {
|
||
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;
|
||
|
||
// Тестируем с пустыми данными
|
||
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"
|
||
);
|
||
}
|
||
|
||
/// Тест для проверки функций core.rs
|
||
#[tokio::test]
|
||
async fn test_core_functions() {
|
||
// Мокаем функцию get_shout_by_id для тестов
|
||
async fn get_shout_by_id(id: u32) -> Result<String, Box<dyn std::error::Error>> {
|
||
if id == 0 || id > 1000000 {
|
||
return Err("Invalid shout ID".into());
|
||
}
|
||
Ok(format!("Shout content for ID {}", id))
|
||
}
|
||
|
||
// Тестируем с несуществующим ID
|
||
let result = get_shout_by_id(999999).await;
|
||
assert!(result.is_ok(), "Should succeed with valid shout ID");
|
||
|
||
// Тестируем с ID 0 (специальный случай)
|
||
let result = get_shout_by_id(0).await;
|
||
assert!(result.is_err(), "Should fail with ID 0");
|
||
}
|
||
|
||
/// Тест для проверки функций auth.rs
|
||
#[tokio::test]
|
||
async fn test_auth_functions() {
|
||
// Мокаем функции auth для тестов
|
||
async fn get_id_by_token(token: &str) -> Result<u32, Box<dyn std::error::Error>> {
|
||
if token == "invalid_token" {
|
||
return Err("Invalid token".into());
|
||
}
|
||
Ok(123)
|
||
}
|
||
|
||
// Тестируем get_id_by_token с неверным токеном
|
||
let result = get_id_by_token("invalid_token").await;
|
||
assert!(result.is_err(), "Should fail with invalid token");
|
||
}
|
||
|
||
// AppState tests removed - mock struct not actually used
|
||
|
||
// Handler tests removed - mock functions not actually used
|
||
|
||
/// Тест для проверки интеграции основных компонентов
|
||
#[tokio::test]
|
||
async fn test_integration() {
|
||
// Тестируем, что основные модули могут работать вместе
|
||
// Мокаем функции для интеграционного теста
|
||
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
|
||
};
|
||
|
||
// Ищем 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()
|
||
};
|
||
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()
|
||
};
|
||
(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,
|
||
}
|
||
}
|
||
|
||
let filename = "test_image_300.jpg";
|
||
let (base, width, ext) = parse_file_path(filename);
|
||
let mime_type = get_mime_type(&ext);
|
||
|
||
assert_eq!(base, "test_image");
|
||
assert_eq!(width, 300);
|
||
assert_eq!(ext, "jpg");
|
||
assert_eq!(mime_type, Some("image/jpeg"));
|
||
}
|
||
|
||
/// Тест для проверки обработки граничных случаев
|
||
#[tokio::test]
|
||
async fn test_edge_cases() {
|
||
// Мокаем функцию parse_file_path для теста граничных случаев
|
||
fn parse_file_path(path: &str) -> (String, u32, String) {
|
||
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
|
||
};
|
||
|
||
// Ищем 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()
|
||
};
|
||
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()
|
||
};
|
||
(base, 0, ext)
|
||
}
|
||
|
||
// Тестируем пустые строки
|
||
assert_eq!(parse_file_path(""), ("".to_string(), 0, "".to_string()));
|
||
assert_eq!(parse_file_path("."), (".".to_string(), 0, "".to_string()));
|
||
assert_eq!(parse_file_path(".."), ("..".to_string(), 0, "".to_string()));
|
||
|
||
// Тестируем очень длинные имена файлов
|
||
let long_name = "a".repeat(1000);
|
||
let long_filename = format!("{}_300.jpg", long_name);
|
||
let (_base, width, ext) = parse_file_path(&long_filename);
|
||
assert_eq!(width, 300);
|
||
assert_eq!(ext, "jpg");
|
||
|
||
// Тестируем специальные символы
|
||
let special_filename = "file-with-dashes_300.jpg";
|
||
let (base, width, ext) = parse_file_path(special_filename);
|
||
assert_eq!(base, "file-with-dashes");
|
||
assert_eq!(width, 300);
|
||
assert_eq!(ext, "jpg");
|
||
}
|
||
|
||
/// Тест для проверки производительности парсинга
|
||
#[tokio::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
|
||
};
|
||
|
||
// Ищем 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()
|
||
};
|
||
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()
|
||
};
|
||
(base, 0, ext)
|
||
}
|
||
|
||
let test_paths = vec![
|
||
"image_300.jpg",
|
||
"photo_800.png",
|
||
"document.pdf",
|
||
"file_with_underscore_but_no_width.gif",
|
||
"unsafe_1920x.jpg",
|
||
];
|
||
|
||
let iterations = 10000;
|
||
let start = Instant::now();
|
||
|
||
for _ in 0..iterations {
|
||
for path in &test_paths {
|
||
let _ = parse_file_path(path);
|
||
}
|
||
}
|
||
|
||
let duration = start.elapsed();
|
||
let avg_time = duration.as_nanos() as f64 / (iterations * test_paths.len()) as f64;
|
||
|
||
println!(
|
||
"Path parsing: {} iterations in {:?}, avg: {:.2} ns per parse",
|
||
iterations * test_paths.len(),
|
||
duration,
|
||
avg_time
|
||
);
|
||
|
||
// Проверяем, что парсинг достаточно быстрый (реалистичный порог для CI)
|
||
assert!(
|
||
avg_time < 2000.0,
|
||
"Path parsing too slow: {:.2} ns per parse",
|
||
avg_time
|
||
);
|
||
}
|