fmt

2025-09-01 22:58:03 +03:00
parent d6b286f478
commit 112f102bb5
14 changed files with 444 additions and 316 deletions
--- a/tests/handler_tests.rs
+++ b/tests/handler_tests.rs
@@ -1,8 +1,7 @@
-use actix_web::{test, web, App, HttpRequest, HttpResponse, Error as ActixError};
 use actix_web::http::StatusCode;
+use actix_web::{App, Error as ActixError, HttpRequest, HttpResponse, test, web};
 use serde_json::json;

-
 // Мокаем необходимые структуры и функции для тестов

 /// Мок для Redis соединения
@@ -36,7 +35,11 @@ impl MockAppState {
        Ok(1024 * 1024) // 1MB
    }

-    async fn increase_user_quota(&self, _user_id: &str, _additional_bytes: u64) -> Result<u64, actix_web::Error> {
+    async fn increase_user_quota(
+        &self,
+        _user_id: &str,
+        _additional_bytes: u64,
+    ) -> Result<u64, actix_web::Error> {
        Ok(2 * 1024 * 1024) // 2MB
    }

@@ -64,12 +67,13 @@ async fn test_get_quota_handler() {
    async fn get_quota_handler() -> actix_web::HttpResponse {
        actix_web::HttpResponse::Ok().json(serde_json::json!({"quota": 1024}))
    }
-    
+
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/quota", web::get().to(get_quota_handler))
-    ).await;
+            .route("/quota", web::get().to(get_quota_handler)),
+    )
+    .await;

    // Тест без авторизации
    let req = test::TestRequest::get()
@@ -98,12 +102,13 @@ async fn test_increase_quota_handler() {
    async fn increase_quota_handler() -> actix_web::HttpResponse {
        actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "increased"}))
    }
-    
+
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/quota/increase", web::post().to(increase_quota_handler))
-    ).await;
+            .route("/quota/increase", web::post().to(increase_quota_handler)),
+    )
+    .await;

    // Тест без авторизации
    let req = test::TestRequest::post()
@@ -132,17 +137,16 @@ async fn test_set_quota_handler() {
    async fn set_quota_handler() -> actix_web::HttpResponse {
        actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "set"}))
    }
-    
+
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/quota/set", web::post().to(set_quota_handler))
-    ).await;
+            .route("/quota/set", web::post().to(set_quota_handler)),
+    )
+    .await;

    // Тест без авторизации
-    let req = test::TestRequest::post()
-        .uri("/quota/set")
-        .to_request();
+    let req = test::TestRequest::post().uri("/quota/set").to_request();

    let resp = test::call_service(&app, req).await;
    // Мок возвращает успешный ответ даже без авторизации
@@ -166,17 +170,16 @@ async fn test_upload_handler() {
    async fn upload_handler() -> actix_web::HttpResponse {
        actix_web::HttpResponse::Ok().json(serde_json::json!({"status": "uploaded"}))
    }
-    
+
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/", web::post().to(upload_handler))
-    ).await;
+            .route("/", web::post().to(upload_handler)),
+    )
+    .await;

    // Тест без авторизации
-    let req = test::TestRequest::post()
-        .uri("/")
-        .to_request();
+    let req = test::TestRequest::post().uri("/").to_request();

    let resp = test::call_service(&app, req).await;
    // Мок возвращает успешный ответ даже без авторизации
@@ -200,12 +203,13 @@ async fn test_proxy_handler() {
    async fn proxy_handler() -> actix_web::HttpResponse {
        actix_web::HttpResponse::Ok().body("proxy response")
    }
-    
+
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/{path:.*}", web::get().to(proxy_handler))
-    ).await;
+            .route("/{path:.*}", web::get().to(proxy_handler)),
+    )
+    .await;

    // Тест с несуществующим файлом
    let req = test::TestRequest::get()
@@ -221,12 +225,16 @@ async fn test_proxy_handler() {
 #[actix_web::test]
 async fn test_serve_file() {
    // Мокаем функцию serve_file
-    async fn serve_file(_path: &str, _app_state: &MockAppState, _user_id: &str) -> Result<actix_web::HttpResponse, actix_web::Error> {
+    async fn serve_file(
+        _path: &str,
+        _app_state: &MockAppState,
+        _user_id: &str,
+    ) -> Result<actix_web::HttpResponse, actix_web::Error> {
        Err(actix_web::error::ErrorNotFound("File not found"))
    }
-    
+
    let app_state = MockAppState::new();
-    
+
    // Тест с пустым путем
    let result = serve_file("", &app_state, "").await;
    assert!(result.is_err());
@@ -243,12 +251,16 @@ async fn test_handler_error_handling() {
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/test", web::get().to(|_req: HttpRequest| async {
-                Err::<HttpResponse, ActixError>(
-                    actix_web::error::ErrorInternalServerError("Test error")
-                )
-            }))
-    ).await;
+            .route(
+                "/test",
+                web::get().to(|_req: HttpRequest| async {
+                    Err::<HttpResponse, ActixError>(actix_web::error::ErrorInternalServerError(
+                        "Test error",
+                    ))
+                }),
+            ),
+    )
+    .await;

    let req = test::TestRequest::get().uri("/test").to_request();
    let resp = test::call_service(&app, req).await;
@@ -261,19 +273,21 @@ async fn test_cors_headers() {
    let app = test::init_service(
        App::new()
            .app_data(web::Data::new(MockAppState::new()))
-            .route("/test", web::get().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().body("test")
-                )
-            }))
-            .wrap(actix_cors::Cors::default().allow_any_origin())
-    ).await;
+            .route(
+                "/test",
+                web::get().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(HttpResponse::Ok().body("test"))
+                }),
+            )
+            .wrap(actix_cors::Cors::default().allow_any_origin()),
+    )
+    .await;

    let req = test::TestRequest::get().uri("/test").to_request();
    let resp = test::call_service(&app, req).await;
-    
+
    assert!(resp.status().is_success());
-    
+
    // Проверяем наличие CORS headers
    let headers = resp.headers();
    // В тестовой среде CORS headers могут не добавляться автоматически
@@ -286,23 +300,26 @@ async fn test_cors_headers() {
 async fn test_http_methods() {
    let app = test::init_service(
        App::new()
-            .route("/test", web::get().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().body("GET method")
-                )
-            }))
-            .route("/test", web::post().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().body("POST method")
-                )
-            }))
-    ).await;
+            .route(
+                "/test",
+                web::get().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(HttpResponse::Ok().body("GET method"))
+                }),
+            )
+            .route(
+                "/test",
+                web::post().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(HttpResponse::Ok().body("POST method"))
+                }),
+            ),
+    )
+    .await;

    // Тест GET метода
    let req = test::TestRequest::get().uri("/test").to_request();
    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());
-    
+
    let body = test::read_body(resp).await;
    assert_eq!(body, "GET method");

@@ -310,7 +327,7 @@ async fn test_http_methods() {
    let req = test::TestRequest::post().uri("/test").to_request();
    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());
-    
+
    let body = test::read_body(resp).await;
    assert_eq!(body, "POST method");
 }
@@ -318,23 +335,22 @@ async fn test_http_methods() {
 /// Тест для проверки query параметров
 #[actix_web::test]
 async fn test_query_parameters() {
-    let app = test::init_service(
-        App::new()
-            .route("/test", web::get().to(|req: HttpRequest| async move {
-                let query_string = req.query_string().to_string();
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().body(query_string)
-                )
-            }))
-    ).await;
+    let app = test::init_service(App::new().route(
+        "/test",
+        web::get().to(|req: HttpRequest| async move {
+            let query_string = req.query_string().to_string();
+            Ok::<HttpResponse, ActixError>(HttpResponse::Ok().body(query_string))
+        }),
+    ))
+    .await;

    let req = test::TestRequest::get()
        .uri("/test?param1=value1&param2=value2")
        .to_request();
-    
+
    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());
-    
+
    let body = test::read_body(resp).await;
    assert_eq!(body, "param1=value1&param2=value2");
 }
@@ -342,29 +358,29 @@ async fn test_query_parameters() {
 /// Тест для проверки headers
 #[actix_web::test]
 async fn test_headers() {
-    let app = test::init_service(
-        App::new()
-            .route("/test", web::get().to(|req: HttpRequest| async move {
-                let user_agent = req.headers()
-                    .get("user-agent")
-                    .and_then(|h| h.to_str().ok())
-                    .unwrap_or("unknown")
-                    .to_string();
-                
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().body(user_agent)
-                )
-            }))
-    ).await;
+    let app = test::init_service(App::new().route(
+        "/test",
+        web::get().to(|req: HttpRequest| async move {
+            let user_agent = req
+                .headers()
+                .get("user-agent")
+                .and_then(|h| h.to_str().ok())
+                .unwrap_or("unknown")
+                .to_string();
+
+            Ok::<HttpResponse, ActixError>(HttpResponse::Ok().body(user_agent))
+        }),
+    ))
+    .await;

    let req = test::TestRequest::get()
        .uri("/test")
        .insert_header(("user-agent", "test-agent"))
        .to_request();
-    
+
    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());
-    
+
    let body = test::read_body(resp).await;
    assert_eq!(body, "test-agent");
 }
@@ -372,31 +388,30 @@ async fn test_headers() {
 /// Тест для проверки JSON responses
 #[actix_web::test]
 async fn test_json_responses() {
-    let app = test::init_service(
-        App::new()
-            .route("/test", web::get().to(|_req: HttpRequest| async {
-                let data = json!({
-                    "status": "success",
-                    "message": "test message",
-                    "data": {
-                        "id": 123,
-                        "name": "test"
-                    }
-                });
-                
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok().json(data)
-                )
-            }))
-    ).await;
+    let app = test::init_service(App::new().route(
+        "/test",
+        web::get().to(|_req: HttpRequest| async {
+            let data = json!({
+                "status": "success",
+                "message": "test message",
+                "data": {
+                    "id": 123,
+                    "name": "test"
+                }
+            });
+
+            Ok::<HttpResponse, ActixError>(HttpResponse::Ok().json(data))
+        }),
+    ))
+    .await;

    let req = test::TestRequest::get().uri("/test").to_request();
    let resp = test::call_service(&app, req).await;
    assert!(resp.status().is_success());
-    
+
    let body = test::read_body(resp).await;
    let response_data: serde_json::Value = serde_json::from_slice(&body).unwrap();
-    
+
    assert_eq!(response_data["status"], "success");
    assert_eq!(response_data["message"], "test message");
    assert_eq!(response_data["data"]["id"], 123);
@@ -408,41 +423,54 @@ async fn test_json_responses() {
 async fn test_content_types() {
    let app = test::init_service(
        App::new()
-            .route("/text", web::get().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok()
-                        .content_type("text/plain")
-                        .body("plain text")
-                )
-            }))
-            .route("/html", web::get().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok()
-                        .content_type("text/html")
-                        .body("<html><body>test</body></html>")
-                )
-            }))
-            .route("/json", web::get().to(|_req: HttpRequest| async {
-                Ok::<HttpResponse, ActixError>(
-                    HttpResponse::Ok()
-                        .content_type("application/json")
-                        .json(json!({"test": "data"}))
-                )
-            }))
-    ).await;
+            .route(
+                "/text",
+                web::get().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(
+                        HttpResponse::Ok()
+                            .content_type("text/plain")
+                            .body("plain text"),
+                    )
+                }),
+            )
+            .route(
+                "/html",
+                web::get().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(
+                        HttpResponse::Ok()
+                            .content_type("text/html")
+                            .body("<html><body>test</body></html>"),
+                    )
+                }),
+            )
+            .route(
+                "/json",
+                web::get().to(|_req: HttpRequest| async {
+                    Ok::<HttpResponse, ActixError>(
+                        HttpResponse::Ok()
+                            .content_type("application/json")
+                            .json(json!({"test": "data"})),
+                    )
+                }),
+            ),
+    )
+    .await;

    // Тест text/plain
    let req = test::TestRequest::get().uri("/text").to_request();
    let resp = test::call_service(&app, req).await;
    assert_eq!(resp.headers().get("content-type").unwrap(), "text/plain");
-    
+
    // Тест text/html
    let req = test::TestRequest::get().uri("/html").to_request();
    let resp = test::call_service(&app, req).await;
    assert_eq!(resp.headers().get("content-type").unwrap(), "text/html");
-    
+
    // Тест application/json
    let req = test::TestRequest::get().uri("/json").to_request();
    let resp = test::call_service(&app, req).await;
-    assert_eq!(resp.headers().get("content-type").unwrap(), "application/json");
+    assert_eq!(
+        resp.headers().get("content-type").unwrap(),
+        "application/json"
+    );
 }