0.3.0-less-expect

tests/handler_tests.rs

@@ -0,0 +1,404 @@
+use actix_web::{test, web, App, HttpRequest, HttpResponse, Error as ActixError};
+use actix_web::http::StatusCode;
+use serde_json::json;
+use std::collections::HashMap;
+
+use discoursio_quoter::{
+    app_state::AppState,
+    handlers::{
+        get_quota_handler, increase_quota_handler, set_quota_handler,
+        upload_handler, proxy_handler, serve_file
+    },
+    auth::get_id_by_token,
+};
+
+/// Мок для Redis соединения
+#[derive(Clone)]
+struct MockRedisConnection;
+
+/// Мок для S3 клиента
+#[derive(Clone)]
+struct MockS3Client;
+
+/// Мок для AppState
+#[derive(Clone)]
+struct MockAppState {
+    redis: MockRedisConnection,
+    storj_client: MockS3Client,
+    aws_client: MockS3Client,
+    bucket: String,
+}
+
+impl MockAppState {
+    fn new() -> Self {
+        Self {
+            redis: MockRedisConnection,
+            storj_client: MockS3Client,
+            aws_client: MockS3Client,
+            bucket: "test-bucket".to_string(),
+        }
+    }
+
+    async fn get_or_create_quota(&self, _user_id: &str) -> Result<u64, actix_web::Error> {
+        Ok(1024 * 1024) // 1MB
+    }
+
+    async fn increase_user_quota(&self, _user_id: &str, _additional_bytes: u64) -> Result<u64, actix_web::Error> {
+        Ok(2 * 1024 * 1024) // 2MB
+    }
+
+    async fn set_user_quota(&self, _user_id: &str, _bytes: u64) -> Result<u64, actix_web::Error> {
+        Ok(3 * 1024 * 1024) // 3MB
+    }
+
+    async fn get_path(&self, _filename: &str) -> Result<Option<String>, actix_web::Error> {
+        Ok(Some("test/path/file.jpg".to_string()))
+    }
+
+    async fn set_path(&self, _filename: &str, _filepath: &str) {
+        // Mock implementation
+    }
+
+    async fn cache_filelist(&self) {
+        // Mock implementation
+    }
+}
+
+/// Тест для get_quota_handler
+#[actix_web::test]
+async fn test_get_quota_handler() {
+    let app = test::init_service(
+        App::new()
+            .app_data(web::Data::new(MockAppState::new()))
+            .route("/quota", web::get().to(get_quota_handler))
+    ).await;
+
+    // Тест без авторизации
+    let req = test::TestRequest::get()
+        .uri("/quota?user_id=test-user")
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
+
+    // Тест с авторизацией (мокаем токен)
+    let req = test::TestRequest::get()
+        .uri("/quota?user_id=test-user")
+        .header("Authorization", "Bearer valid-token")
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    // Должен вернуть ошибку, так как токен невалидный в тестовой среде
+    assert!(resp.status().is_client_error() || resp.status().is_server_error());
+}
+
+/// Тест для increase_quota_handler
+#[actix_web::test]
+async fn test_increase_quota_handler() {
+    let app = test::init_service(
+        App::new()
+            .app_data(web::Data::new(MockAppState::new()))
+            .route("/quota/increase", web::post().to(increase_quota_handler))
+    ).await;
+
+    let quota_data = json!({
+        "user_id": "test-user",
+        "additional_bytes": 1024 * 1024
+    });
+
+    let req = test::TestRequest::post()
+        .uri("/quota/increase")
+        .header("Authorization", "Bearer valid-token")
+        .set_json(quota_data)
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    // Должен вернуть ошибку, так как токен невалидный в тестовой среде
+    assert!(resp.status().is_client_error() || resp.status().is_server_error());
+}
+
+/// Тест для set_quota_handler
+#[actix_web::test]
+async fn test_set_quota_handler() {
+    let app = test::init_service(
+        App::new()
+            .app_data(web::Data::new(MockAppState::new()))
+            .route("/quota/set", web::post().to(set_quota_handler))
+    ).await;
+
+    let quota_data = json!({
+        "user_id": "test-user",
+        "new_quota_bytes": 5 * 1024 * 1024
+    });
+
+    let req = test::TestRequest::post()
+        .uri("/quota/set")
+        .header("Authorization", "Bearer valid-token")
+        .set_json(quota_data)
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    // Должен вернуть ошибку, так как токен невалидный в тестовой среде
+    assert!(resp.status().is_client_error() || resp.status().is_server_error());
+}
+
+/// Тест для upload_handler
+#[actix_web::test]
+async fn test_upload_handler() {
+    let app = test::init_service(
+        App::new()
+            .app_data(web::Data::new(MockAppState::new()))
+            .route("/", web::post().to(upload_handler))
+    ).await;
+
+    // Тест с пустым multipart
+    let req = test::TestRequest::post()
+        .uri("/")
+        .header("Authorization", "Bearer valid-token")
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    // Должен вернуть ошибку, так как нет multipart данных
+    assert!(resp.status().is_client_error() || resp.status().is_server_error());
+}
+
+/// Тест для proxy_handler
+#[actix_web::test]
+async fn test_proxy_handler() {
+    let app = test::init_service(
+        App::new()
+            .app_data(web::Data::new(MockAppState::new()))
+            .route("/{path:.*}", web::get().to(proxy_handler))
+    ).await;
+
+    // Тест с несуществующим файлом
+    let req = test::TestRequest::get()
+        .uri("/nonexistent.jpg")
+        .to_request();
+
+    let resp = test::call_service(&app, req).await;
+    // Должен вернуть ошибку, так как файл не найден
+    assert!(resp.status().is_client_error() || resp.status().is_server_error());
+}
+
+/// Тест для serve_file
+#[actix_web::test]
+async fn test_serve_file() {
+    let app_state = MockAppState::new();
+    
+    // Тест с пустым путем
+    let result = serve_file("", &app_state, "").await;
+    assert!(result.is_err());
+
+    // Тест с несуществующим файлом
+    let result = serve_file("nonexistent.jpg", &app_state, "").await;
+    // Должен вернуть ошибку, так как файл не найден в S3
+    assert!(result.is_err());
+}
+
+/// Тест для проверки обработки ошибок в handlers
+#[actix_web::test]
+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;
+
+    let req = test::TestRequest::get().uri("/test").to_request();
+    let resp = test::call_service(&app, req).await;
+    assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+}
+
+/// Тест для проверки CORS headers
+#[actix_web::test]
+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;
+
+    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();
+    assert!(headers.contains_key("access-control-allow-origin"));
+}
+
+/// Тест для проверки различных HTTP методов
+#[actix_web::test]
+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;
+
+    // Тест 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");
+
+    // Тест POST метода
+    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");
+}
+
+/// Тест для проверки query параметров
+#[actix_web::test]
+async fn test_query_parameters() {
+    let app = test::init_service(
+        App::new()
+            .route("/test", web::get().to(|req: HttpRequest| async {
+                let query_string = req.query_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");
+}
+
+/// Тест для проверки headers
+#[actix_web::test]
+async fn test_headers() {
+    let app = test::init_service(
+        App::new()
+            .route("/test", web::get().to(|req: HttpRequest| async {
+                let user_agent = req.headers()
+                    .get("user-agent")
+                    .and_then(|h| h.to_str().ok())
+                    .unwrap_or("unknown");
+                
+                Ok::<HttpResponse, ActixError>(
+                    HttpResponse::Ok().body(user_agent)
+                )
+            }))
+    ).await;
+
+    let req = test::TestRequest::get()
+        .uri("/test")
+        .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");
+}
+
+/// Тест для проверки 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 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);
+    assert_eq!(response_data["data"]["name"], "test");
+}
+
+/// Тест для проверки различных content types
+#[actix_web::test]
+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;
+
+    // Тест 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");
+}