//! R-D (AT-3.6-05): настроенный предел содержимого на **реальном** HTTP-пути, //! включая многобайтовую границу и фрагментированное тело без `Content-Length`. //! //! Источник: SPEC v4 D-3/D-9 (configured size, никакого «успешного префикса»), //! TL review run103:35 (R-D: «configured small-L на реальном reader-е с //! fragmentation/interruption/false-or-absent length и неизменным состоянием //! отклонённого обновления»). //! //! Стенд настраивает `ResourceLimits::uniform(SMALL_LIMIT)` через настоящий билдер //! сервиса (composition fixture), поэтому проверяется работающий сервис, а не //! отдельная функция валидации. Фрагментированные запросы идут по реальному //! loopback-сокету: `reqwest` всегда добавляет `Content-Length`, а здесь нужен //! именно chunked-поток. //! //! Канонический прогон: `cargo test -p admin-api --lib //! service::resources::tests::limits -- --test-threads=1`. use reqwest::StatusCode; use serial_test::serial; use super::counters; use crate::app::resource_test_support::{ GuardHarness, GuardOptions, LoginOptions, OWNER_EMAIL, OWNER_PASSWORD, created_resource_id, draft_metadata, draft_updated_at, error_signature, get_raw, login_client, raw_session, resource_row_counts, send_chunked_multipart, }; /// Малое настроенное L: границы L−1/L/L+1 проверяются без 256 KiB payload. const SMALL_LIMIT: usize = 16; const BOUNDARY: &str = "story36limitsboundary"; enum Expectation { Accepted, TooLarge, } struct LimitCase { label: &'static str, kind: &'static str, mime: &'static str, bytes: Vec, expectation: Expectation, } fn json_document(length: usize) -> Vec { assert!(length >= 9, "a JSON envelope needs at least nine bytes"); format!("{{\"k\":\"{}\"}}", "a".repeat(length - 8)).into_bytes() } fn binary_document(length: usize) -> Vec { // Произвольные байты, включая не-UTF8 последовательности и нули. (0..length) .map(|index| (index as u8).wrapping_mul(37).wrapping_add(0x80)) .collect() } fn limit_cases() -> Vec { let small = SMALL_LIMIT; let mut cases = Vec::new(); for (label, length, expectation) in [ ("text_l_minus_one", small - 1, Expectation::Accepted), ("text_l", small, Expectation::Accepted), ("text_l_plus_one", small + 1, Expectation::TooLarge), ] { cases.push(LimitCase { label, kind: "text", mime: "text/plain", bytes: vec![b'a'; length], expectation, }); } // Многобайтовый символ ровно на границе: не помещается — отвергается целиком. let mut fits = vec![b'a'; small - 2]; fits.extend_from_slice("\u{e9}".as_bytes()); assert_eq!(fits.len(), small); let mut over = vec![b'a'; small - 1]; over.extend_from_slice("\u{e9}".as_bytes()); assert_eq!(over.len(), small + 1); cases.push(LimitCase { label: "text_multibyte_fits", kind: "text", mime: "text/plain", bytes: fits, expectation: Expectation::Accepted, }); cases.push(LimitCase { label: "text_multibyte_over", kind: "text", mime: "text/plain", bytes: over, expectation: Expectation::TooLarge, }); for (label, length, expectation) in [ ("json_l_minus_one", small - 1, Expectation::Accepted), ("json_l", small, Expectation::Accepted), ("json_l_plus_one", small + 1, Expectation::TooLarge), ] { cases.push(LimitCase { label, kind: "json", mime: "application/json", bytes: json_document(length), expectation, }); } for (label, length, expectation) in [ ("binary_l_minus_one", small - 1, Expectation::Accepted), ("binary_l", small, Expectation::Accepted), ("binary_l_plus_one", small + 1, Expectation::TooLarge), ] { cases.push(LimitCase { label, kind: "binary", mime: "image/png", bytes: binary_document(length), expectation, }); } cases } async fn download_bytes(client: &reqwest::Client, url: &str) -> (StatusCode, Vec) { let response = client .get(url) .send() .await .expect("the content request must complete"); let status = response.status(); let bytes = response .bytes() .await .expect("the content body must be readable") .to_vec(); (status, bytes) } async fn owner_client(harness: &GuardHarness) -> reqwest::Client { login_client( &harness.root_url, OWNER_EMAIL, OWNER_PASSWORD, LoginOptions::with_csrf(), ) .await } fn raw_multipart(metadata: &serde_json::Value, content: &[u8], mime: &str) -> Vec { let head = format!( "--{BOUNDARY}\r\nContent-Disposition: form-data; name=\"metadata\"; filename=\"metadata.json\"\r\n\ Content-Type: application/json\r\n\r\n{}\r\n\ --{BOUNDARY}\r\nContent-Disposition: form-data; name=\"content\"; filename=\"draft.bin\"\r\n\ Content-Type: {mime}\r\n\r\n", serde_json::to_string(metadata).expect("metadata must serialize") ); let mut body = head.into_bytes(); body.extend_from_slice(content); body.extend_from_slice(format!("\r\n--{BOUNDARY}--\r\n").as_bytes()); body } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at05_configured_small_limit_boundaries_through_real_http() { let harness = GuardHarness::spawn_with( "limits", GuardOptions { resource_limit: Some(SMALL_LIMIT), ..GuardOptions::default() }, ) .await; let owner = owner_client(&harness).await; let mut observations: Vec = Vec::new(); let mut mismatches: Vec = Vec::new(); let mut accepted = 0usize; for case in limit_cases() { let metadata = draft_metadata( &format!("crank://limit/{}", case.label), case.label, case.kind, case.mime, "internal", ); let (status, _traceable, text, body) = crate::app::resource_test_support::post_draft( &owner, &harness.resources_url(), &metadata, &case.bytes, case.mime, ) .await; let code = body["error"]["code"] .as_str() .unwrap_or("") .to_owned(); match case.expectation { Expectation::Accepted => { accepted += 1; let id = match ( status.is_success(), body["resource"]["resource_id"].as_str(), ) { (true, Some(id)) => id.to_owned(), _ => { mismatches.push(format!( "{}: expected success, observed {}", case.label, error_signature(status, &body) )); observations.push(format!("{}: {status} {code}", case.label)); continue; } }; let (content_status, bytes) = download_bytes(&owner, &harness.nested_url(&id, "content")).await; if content_status == StatusCode::OK && bytes == case.bytes { observations.push(format!("{}: 201 + exact {} bytes", case.label, bytes.len())); } else { mismatches.push(format!( "{}: content readback mismatch (status={content_status}, {} bytes)", case.label, bytes.len() )); observations.push(format!("{}: content status={content_status}", case.label)); } } Expectation::TooLarge => { if status == StatusCode::PAYLOAD_TOO_LARGE && code == "resource_content_too_large" { observations.push(format!("{}: 413 {code}", case.label)); } else { mismatches.push(format!( "{}: expected 413 resource_content_too_large, observed {}", case.label, error_signature(status, &body) )); observations.push(format!("{}: {status} {code} body={text}", case.label)); } } } } assert_eq!( harness.accepted_drafts().await.len(), accepted, "a refused bounded body must not leave an accepted draft; observations: {observations:?}" ); assert!( mismatches.is_empty(), "every configured-L boundary must be exact for text/JSON/binary, multibyte included; \ observations: {observations:?}; mismatches: {mismatches:?}" ); // Фрагментированное тело (chunked, без `Content-Length`): тот же предел действует, // «успешного префикса» не возникает. let session = raw_session(&harness.root_url, OWNER_EMAIL, OWNER_PASSWORD).await; let resources_url = harness.resources_url(); let path = resources_url[resources_url.find("/api").expect("admin prefix")..].to_owned(); let accepted_meta = draft_metadata( "crank://limit/chunked_ok", "chunked_ok", "text", "text/plain", "internal", ); let accepted_body = raw_multipart(&accepted_meta, &[b'c'; SMALL_LIMIT], "text/plain"); let chunks: Vec> = accepted_body .chunks(23) .map(|chunk| chunk.to_vec()) .collect(); assert!( chunks.len() >= 3, "the fragmented request must really be sent in several chunks" ); let response = send_chunked_multipart(harness.addr, &path, &session, BOUNDARY, &chunks).await; let accepted_fragmented_ok = response.status == 201 && response.write_error.is_none(); observations.push(format!( "fragmented-L: expected 201, observed {}", response.signature() )); let over_meta = draft_metadata( "crank://limit/chunked_over", "chunked_over", "text", "text/plain", "internal", ); let over_body = raw_multipart(&over_meta, &[b'c'; SMALL_LIMIT + 1], "text/plain"); let over_chunks: Vec> = over_body.chunks(19).map(|chunk| chunk.to_vec()).collect(); let response = send_chunked_multipart(harness.addr, &path, &session, BOUNDARY, &over_chunks).await; let over_fragmented_ok = response.status == 413 && response.body.contains("resource_content_too_large"); observations.push(format!( "fragmented-L+1: expected 413 resource_content_too_large, observed {}", response.signature() )); // Прерванное тело (нет закрывающей границы): клиентский отказ, ничего принято не было. let truncated_meta = draft_metadata( "crank://limit/chunked_truncated", "chunked_truncated", "text", "text/plain", "internal", ); let mut truncated_body = raw_multipart(&truncated_meta, b"short", "text/plain"); truncated_body.truncate(truncated_body.len() - 20); let truncated_chunks: Vec> = truncated_body .chunks(17) .map(|chunk| chunk.to_vec()) .collect(); let response = send_chunked_multipart(harness.addr, &path, &session, BOUNDARY, &truncated_chunks).await; let interrupted_ok = response.status == 400; observations.push(format!( "interrupted-multipart: expected 400, observed {}", response.signature() )); let drafts = harness.accepted_drafts().await; let only_accepted_fragmented_draft = drafts.len() == accepted + 1; assert!( only_accepted_fragmented_draft, "only the accepted fragmented draft may be added; observations: {observations:?}" ); assert!( accepted_fragmented_ok && over_fragmented_ok, "a fragmented body without Content-Length must obey the same limit (no prefix \ acceptance); observations: {observations:?}" ); assert!( interrupted_ok, "an interrupted multipart body must be a client error (P2), not a limit refusal; \ observations: {observations:?}" ); } #[tokio::test(flavor = "multi_thread")] #[serial] async fn story36_at05_rejected_update_keeps_state_and_checksum() { let harness = GuardHarness::spawn_with( "limits_update", GuardOptions { resource_limit: Some(SMALL_LIMIT), ..GuardOptions::default() }, ) .await; let owner = owner_client(&harness).await; let metadata = draft_metadata( "crank://limit/update", "limit_update", "text", "text/plain", "internal", ); let created = crate::app::resource_test_support::post_draft( &owner, &harness.resources_url(), &metadata, b"initial body", "text/plain", ) .await; assert_eq!( created.0, StatusCode::CREATED, "the seed draft must be created: {}", created.2 ); let id = created_resource_id(&created.3); let card = get_raw(&owner, &harness.resource_url(&id)).await.3; let updated_at = draft_updated_at(&card); let digest_before = card["version"]["digest"] .as_str() .unwrap_or_default() .to_owned(); // Полное «до»: карточка целиком, точные bytes и итоги строк/ссылок V16. Отказ обязан // оставить неизменным всё это, а не только версию/чек-сумму/описание (TL run105 F2). let (content_status_before, bytes_before) = download_bytes(&owner, &harness.nested_url(&id, "content")).await; assert_eq!(content_status_before, StatusCode::OK); let counts_before = resource_row_counts(harness.registry.pool()).await; // Счётчики физических точек сбрасываются **после** собственного наблюдения, чтобы // измерялся вклад самого отклонённого запроса, а не теста. counters::reset(); // Отклонённое обновление: тело выше настроенного L. let update = serde_json::json!({ "description": "should not apply", "mime_type": "text/plain", "sensitivity": "public", "expected_updated_at": updated_at, }); let (status, _headers, text, body) = crate::app::resource_test_support::put_draft( &owner, &harness.resource_url(&id), &update, &[b'z'; SMALL_LIMIT + 1], "text/plain", ) .await; assert_eq!( status, StatusCode::PAYLOAD_TOO_LARGE, "L+1 on update must be a limit refusal: {}", error_signature(status, &body) ); assert_eq!( body["error"]["code"], serde_json::json!("resource_content_too_large"), "body={text}" ); // Наблюдение физических точек сразу после отказа: измеряется вклад отклонённого запроса. let puts_after_refusal = counters::artifact_puts(); let reads_after_refusal = counters::artifact_reads(); // Полное состояние после отказа: карточка целиком (включая `updated_at`, MIME и // sensitivity), точные bytes и итоги строк/ссылок V16 не изменились. let after = get_raw(&owner, &harness.resource_url(&id)).await.3; assert_eq!( after["version"]["version"], serde_json::json!(1), "a refused update must not create a version: {after}" ); assert_eq!( after["version"]["digest"].as_str().unwrap_or_default(), digest_before, "a refused update must not change the recorded checksum" ); assert_eq!( after["resource"]["description"], serde_json::json!(""), "a refused update must not apply the description: {after}" ); assert_eq!( after, card, "a refused update must leave the whole card unchanged, including `updated_at`, \ `mime_type` and `sensitivity` (TL run105 F2)" ); let counts_after = resource_row_counts(harness.registry.pool()).await; assert_eq!( counts_after, counts_before, "a refused update must not add rows, owning references or blobs (TL run105 F2)" ); let (content_status, bytes) = download_bytes(&owner, &harness.nested_url(&id, "content")).await; assert_eq!(content_status, StatusCode::OK); assert_eq!( bytes, b"initial body", "a refused update must keep the previously accepted bytes" ); assert_eq!( bytes, bytes_before, "the pre-refusal read must be the same content" ); assert_eq!( puts_after_refusal, 0, "an oversized update must be refused before any bytes are registered \ (D-20 ordering: limit check precedes the physical put)" ); assert_eq!( reads_after_refusal, 0, "an oversized update must not read any stored bytes" ); }