fix(import): подтвердить обязательные гарантии второго эпика
This commit is contained in:
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(®istry, "ws_external_concurrent_a").await;
|
||||
let workspace_b = create_workspace(®istry, "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(®istry, "ws_external_oracle_a").await;
|
||||
let workspace_b = create_workspace(®istry, "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));
|
||||
}
|
||||
Reference in new issue
Block a user