fix(import): подтвердить обязательные гарантии второго эпика
CI / Rust Checks (pull_request) Successful in 24m43s
CI / UI Checks (pull_request) Successful in 6s
CI / Community Image Smoke (pull_request) Successful in 9m5s
CI / Frontend E2E (pull_request) Successful in 12m43s
CI / Deploy (pull_request) Skipped

This commit is contained in:
bsodfather committed 2026-10-10 13:25:05 +03:00
1 parent 31f6f00d3b
commit ad23cd9a46
33 files changed
+3328 -18

No files matched your search

@@ -0,0 +1,287 @@
use super::*;
use std::time::Duration;
use tokio::sync::Notify;
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn concurrent_external_previews_keep_snapshot_ownership_workspace_scoped() {
let fetches = Arc::new(AtomicUsize::new(0));
let fetch_count = Arc::clone(&fetches);
let app = Router::new().route(
"/schema.yaml",
get(move || {
let fetch_count = Arc::clone(&fetch_count);
async move {
fetch_count.fetch_add(1, Ordering::SeqCst);
"Item: { type: object, properties: { id: { type: string } } }"
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let storage_root = test_storage_root("openapi_import_external_workspace_isolation");
let service = test_service_with_external_references(
registry.clone(),
storage_root.clone(),
vec![format!("{origin}/")],
);
let workspace_a = create_workspace(&registry, "ws_external_concurrent_a").await;
let workspace_b = create_workspace(&registry, "ws_external_concurrent_b").await;
let (preview_a, preview_b) = tokio::join!(
service.preview_openapi_import(&workspace_a, external_upload(&origin)),
service.preview_openapi_import(&workspace_b, external_upload(&origin)),
);
let preview_a = preview_a.unwrap();
let preview_b = preview_b.unwrap();
server.abort();
assert_eq!(
fetches.load(Ordering::SeqCst),
2,
"each workspace fetches its own preview snapshot"
);
assert_ne!(preview_a.job_id, preview_b.job_id);
let job_a = registry
.get_import_job(&workspace_a, &preview_a.job_id.as_str().into())
.await
.unwrap()
.unwrap();
let job_b = registry
.get_import_job(&workspace_b, &preview_b.job_id.as_str().into())
.await
.unwrap()
.unwrap();
let dependency_a = &job_a.preview_payload["dependencies"][0];
let dependency_b = &job_b.preview_payload["dependencies"][0];
let source_a = ArtifactSourceId::new(dependency_a["source_id"].as_str().unwrap());
let source_b = ArtifactSourceId::new(dependency_b["source_id"].as_str().unwrap());
let digest_a = dependency_a["digest"].as_str().unwrap();
let digest_b = dependency_b["digest"].as_str().unwrap();
let canonical_uri = dependency_a["canonical_uri"].as_str().unwrap();
assert_eq!(
digest_a, digest_b,
"identical bytes may share the immutable blob"
);
assert_eq!(dependency_b["canonical_uri"], dependency_a["canonical_uri"]);
assert_ne!(
source_a, source_b,
"each workspace owns a distinct source relation"
);
let public_a = serde_json::to_string(&preview_a).unwrap();
let public_b = serde_json::to_string(&preview_b).unwrap();
for response in [&public_a, &public_b] {
assert!(!response.contains("src_openapi_dep_"));
assert!(!response.contains(digest_a));
assert!(!response.contains(canonical_uri));
}
let store = Arc::new(ArtifactStore::open(&storage_root).unwrap());
for (workspace_id, source_id) in [(&workspace_a, &source_a), (&workspace_b, &source_b)] {
let source = registry
.get_artifact_source(workspace_id, source_id)
.await
.unwrap();
assert_eq!(source.workspace_id, *workspace_id);
assert_eq!(source.blob.artifact_ref.as_str(), digest_a);
let verified = registry
.read_artifact_source(Arc::clone(&store), workspace_id, source_id)
.await
.unwrap();
assert_eq!(
verified.bytes,
b"Item: { type: object, properties: { id: { type: string } } }"
);
}
let foreign_body = source_not_found_body(
registry
.read_artifact_source(Arc::clone(&store), &workspace_b, &source_a)
.await
.expect_err("workspace B cannot resolve workspace A source"),
)
.await;
let unknown_source = ArtifactSourceId::new("src_unknown_workspace_probe");
let unknown_body = source_not_found_body(
registry
.read_artifact_source(Arc::clone(&store), &workspace_b, &unknown_source)
.await
.expect_err("unknown source is indistinguishable from a foreign source"),
)
.await;
assert_eq!(foreign_body, unknown_body);
let response = foreign_body.to_string();
assert!(!response.contains(digest_a));
assert!(!response.contains(canonical_uri));
assert!(!response.contains(source_a.as_str()));
assert!(!response.contains("exists"));
}
#[tokio::test(flavor = "multi_thread")]
#[serial]
async fn existing_foreign_snapshot_does_not_short_circuit_second_workspace_fetch() {
let fetches = Arc::new(AtomicUsize::new(0));
let fetch_count = Arc::clone(&fetches);
let second_fetch_entered = Arc::new(Notify::new());
let entered = Arc::clone(&second_fetch_entered);
let release_second_fetch = Arc::new(Notify::new());
let release = Arc::clone(&release_second_fetch);
let app = Router::new().route(
"/schema.yaml",
get(move || {
let fetch_count = Arc::clone(&fetch_count);
let entered = Arc::clone(&entered);
let release = Arc::clone(&release);
async move {
let request_number = fetch_count.fetch_add(1, Ordering::SeqCst) + 1;
if request_number == 2 {
entered.notify_one();
release.notified().await;
}
"Item: { type: object, properties: { id: { type: string } } }"
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let service = test_service_with_external_references(
registry.clone(),
test_storage_root("openapi_import_external_fetch_oracle"),
vec![format!("{origin}/")],
);
let workspace_a = create_workspace(&registry, "ws_external_oracle_a").await;
let workspace_b = create_workspace(&registry, "ws_external_oracle_b").await;
let preview_a = service
.preview_openapi_import(&workspace_a, external_upload(&origin))
.await
.unwrap();
assert_eq!(fetches.load(Ordering::SeqCst), 1);
let preview_b_origin = origin.clone();
let preview_b_workspace = workspace_b.clone();
let mut preview_b_task = tokio::spawn(async move {
service
.preview_openapi_import(&preview_b_workspace, external_upload(&preview_b_origin))
.await
});
tokio::time::timeout(Duration::from_secs(10), second_fetch_entered.notified())
.await
.expect("the second preview must reach its HTTP fetch");
// The fixture holds the real HTTP response. Poll the preview once after
// observing that fetch; it must remain pending until the fixture releases it.
tokio::select! {
biased;
result = &mut preview_b_task => panic!("second preview bypassed its held fetch: {result:?}"),
_ = tokio::task::yield_now() => {}
}
assert_eq!(fetches.load(Ordering::SeqCst), 2);
release_second_fetch.notify_one();
let preview_b = tokio::time::timeout(Duration::from_secs(10), &mut preview_b_task)
.await
.expect("the released second preview should complete")
.unwrap()
.unwrap();
server.abort();
let job_a = registry
.get_import_job(&workspace_a, &preview_a.job_id.as_str().into())
.await
.unwrap()
.unwrap();
let job_b = registry
.get_import_job(&workspace_b, &preview_b.job_id.as_str().into())
.await
.unwrap()
.unwrap();
let source_a = ArtifactSourceId::new(
job_a.preview_payload["dependencies"][0]["source_id"]
.as_str()
.unwrap(),
);
let source_b = ArtifactSourceId::new(
job_b.preview_payload["dependencies"][0]["source_id"]
.as_str()
.unwrap(),
);
assert_ne!(source_a, source_b);
assert_eq!(fetches.load(Ordering::SeqCst), 2);
}
#[tokio::test]
#[serial]
async fn file_origin_and_relative_chain_are_blocked_without_file_or_network_access() {
const PRIVATE_FILE_BYTES: &str = "PrivateCanary: file-origin-secret-must-never-be-read";
const HYPOTHETICAL_FILE_ROOT: &str = "Item: { $ref: './private/canary.yaml#/Secret' }";
let file_fixture_root = test_storage_root("openapi_import_file_origin_fixture");
let private_directory = file_fixture_root.join("private");
std::fs::create_dir_all(&private_directory).unwrap();
std::fs::write(file_fixture_root.join("root.yaml"), HYPOTHETICAL_FILE_ROOT).unwrap();
std::fs::write(
private_directory.join("canary.yaml"),
format!("Secret: {{ type: string, example: '{PRIVATE_FILE_BYTES}' }}"),
)
.unwrap();
let file_origin = url::Url::from_file_path(file_fixture_root.join("root.yaml")).unwrap();
let file_origin_for_response = file_origin.clone();
let requests = Arc::new(AtomicUsize::new(0));
let request_count = Arc::clone(&requests);
let app = Router::new().route(
"/schema.yaml",
get(move || {
let request_count = Arc::clone(&request_count);
async move {
request_count.fetch_add(1, Ordering::SeqCst);
format!("Item: {{ $ref: '{file_origin_for_response}#/Item' }}")
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let origin = format!("http://{address}");
let registry = test_registry().await;
let service = test_service_with_external_references(
registry,
test_storage_root("openapi_import_file_origin_blocked"),
vec![format!("{origin}/")],
);
let preview = service
.preview_openapi_import(&WorkspaceId::new("ws_default"), external_upload(&origin))
.await
.unwrap();
server.abort();
assert_eq!(
requests.load(Ordering::SeqCst),
1,
"only the explicitly allowlisted HTTP root is fetched"
);
let findings = preview
.preview
.groups
.iter()
.flat_map(|group| &group.operations)
.flat_map(|operation| &operation.findings)
.chain(preview.preview.findings.iter())
.collect::<Vec<_>>();
assert!(
findings.iter().any(|finding| {
finding.severity == crank_import::rest::ImportFindingSeverity::Error
&& finding.code == "reference_target_missing"
}),
"file origin must produce a blocking unresolved-reference finding"
);
let report = serde_json::to_string(&preview).unwrap();
assert!(!report.contains(file_origin.as_str()));
assert!(!report.contains(PRIVATE_FILE_BYTES));
assert!(!report.contains(HYPOTHETICAL_FILE_ROOT));
}