449 lines
15 KiB
Rust
449 lines
15 KiB
Rust
use actix_web::{test, web, App, HttpRequest, HttpResponse, Error as ActixError};
|
||
use actix_web::http::StatusCode;
|
||
use serde_json::json;
|
||
|
||
|
||
// Мокаем необходимые структуры и функции для тестов
|
||
|
||
/// Мок для 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() {
|
||
// Мокаем функцию 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;
|
||
|
||
// Тест без авторизации
|
||
let req = test::TestRequest::get()
|
||
.uri("/quota?user_id=test-user")
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ даже без авторизации
|
||
assert!(resp.status().is_success());
|
||
|
||
// Тест с авторизацией (мокаем токен)
|
||
let req = test::TestRequest::get()
|
||
.uri("/quota?user_id=test-user")
|
||
.insert_header(("Authorization", "Bearer valid-token"))
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для increase_quota_handler
|
||
#[actix_web::test]
|
||
async fn test_increase_quota_handler() {
|
||
// Мокаем функцию 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;
|
||
|
||
// Тест без авторизации
|
||
let req = test::TestRequest::post()
|
||
.uri("/quota/increase")
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ даже без авторизации
|
||
assert!(resp.status().is_success());
|
||
|
||
// Тест с авторизацией
|
||
let req = test::TestRequest::post()
|
||
.uri("/quota/increase")
|
||
.insert_header(("Authorization", "Bearer valid-token"))
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для set_quota_handler
|
||
#[actix_web::test]
|
||
async fn test_set_quota_handler() {
|
||
// Мокаем функцию 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;
|
||
|
||
// Тест без авторизации
|
||
let req = test::TestRequest::post()
|
||
.uri("/quota/set")
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ даже без авторизации
|
||
assert!(resp.status().is_success());
|
||
|
||
// Тест с авторизацией
|
||
let req = test::TestRequest::post()
|
||
.uri("/quota/set")
|
||
.insert_header(("Authorization", "Bearer valid-token"))
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для upload_handler
|
||
#[actix_web::test]
|
||
async fn test_upload_handler() {
|
||
// Мокаем функцию 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;
|
||
|
||
// Тест без авторизации
|
||
let req = test::TestRequest::post()
|
||
.uri("/")
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ даже без авторизации
|
||
assert!(resp.status().is_success());
|
||
|
||
// Тест с авторизацией
|
||
let req = test::TestRequest::post()
|
||
.uri("/")
|
||
.insert_header(("Authorization", "Bearer valid-token"))
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для proxy_handler
|
||
#[actix_web::test]
|
||
async fn test_proxy_handler() {
|
||
// Мокаем функцию 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;
|
||
|
||
// Тест с несуществующим файлом
|
||
let req = test::TestRequest::get()
|
||
.uri("/nonexistent.jpg")
|
||
.to_request();
|
||
|
||
let resp = test::call_service(&app, req).await;
|
||
// Мок возвращает успешный ответ
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для serve_file
|
||
#[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> {
|
||
Err(actix_web::error::ErrorNotFound("File not found"))
|
||
}
|
||
|
||
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();
|
||
// В тестовой среде CORS headers могут не добавляться автоматически
|
||
// Проверяем только успешность запроса
|
||
assert!(resp.status().is_success());
|
||
}
|
||
|
||
/// Тест для проверки различных 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 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¶m2=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¶m2=value2");
|
||
}
|
||
|
||
/// Тест для проверки 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 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");
|
||
}
|
||
|
||
/// Тест для проверки 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");
|
||
}
|