892 lines
29 KiB
Rust
892 lines
29 KiB
Rust
#![allow(dead_code, unused_imports)]
|
|
|
|
use super::common::*;
|
|
|
|
use serde_json::{Value, json};
|
|
use serial_test::serial;
|
|
|
|
mod replay;
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn exposes_server_authoritative_onboarding_projection() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_projection");
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let response = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let status = response.status();
|
|
let body = response.json::<Value>().await.unwrap();
|
|
|
|
assert_eq!(status, reqwest::StatusCode::OK, "body={body}");
|
|
assert_eq!(body["schema_version"], 1);
|
|
assert_eq!(body["status"], "in_progress");
|
|
assert!(body["revision"].as_i64().is_some());
|
|
assert!(body["eligible_since"].as_str().is_some());
|
|
assert_eq!(body["workspace_id"], "ws_default");
|
|
assert_eq!(body["completed"], false);
|
|
assert_eq!(
|
|
body["steps"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|step| step["id"].as_str().unwrap())
|
|
.collect::<Vec<_>>(),
|
|
vec![
|
|
"operation",
|
|
"test",
|
|
"publish_operation",
|
|
"agent",
|
|
"key",
|
|
"mcp_connection",
|
|
"first_call",
|
|
]
|
|
);
|
|
assert!(
|
|
body["steps"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.all(|step| step["completed"] == false)
|
|
);
|
|
assert_eq!(body["steps"][0]["status"], "current");
|
|
assert!(
|
|
body["steps"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.skip(1)
|
|
.all(|step| step["status"] == "pending")
|
|
);
|
|
|
|
// The server-owned eligibility denominator is recorded on the first GET;
|
|
// a repeat is idempotent and cannot advance browser-owned completion.
|
|
let repeated = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(repeated["revision"], body["revision"]);
|
|
assert_eq!(repeated["steps"], body["steps"]);
|
|
assert_eq!(repeated["eligible_since"], body["eligible_since"]);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn ux_milestones_are_idempotent_and_revision_guarded() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_events");
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let initial = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = initial["revision"].as_i64().unwrap();
|
|
let payload = json!({
|
|
"event": "started",
|
|
"idempotency_key": "onboarding-start-tab-a",
|
|
"expected_revision": revision,
|
|
});
|
|
|
|
let first = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&payload)
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let first_status = first.status();
|
|
let first = first.json::<Value>().await.unwrap();
|
|
assert_eq!(first_status, reqwest::StatusCode::OK, "body={first}");
|
|
assert_eq!(first["accepted"], true);
|
|
let accepted_revision = first["revision"].as_i64().unwrap();
|
|
assert_ne!(accepted_revision, revision);
|
|
|
|
let replay = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&payload)
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let replay_status = replay.status();
|
|
let replay = replay.json::<Value>().await.unwrap();
|
|
assert_eq!(replay_status, reqwest::StatusCode::OK, "body={replay}");
|
|
assert_eq!(replay["accepted"], false);
|
|
assert_eq!(replay["revision"], accepted_revision);
|
|
|
|
let semantic_conflict = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&json!({
|
|
"event": "dismissed",
|
|
"idempotency_key": "onboarding-start-tab-a",
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let semantic_conflict_status = semantic_conflict.status();
|
|
let semantic_conflict = semantic_conflict.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
semantic_conflict_status,
|
|
reqwest::StatusCode::CONFLICT,
|
|
"body={semantic_conflict}"
|
|
);
|
|
assert_eq!(
|
|
semantic_conflict["error"]["code"],
|
|
"onboarding_idempotency_conflict"
|
|
);
|
|
|
|
let current_revision_conflict = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&json!({
|
|
"event": "dismissed",
|
|
"idempotency_key": "onboarding-start-tab-a",
|
|
"expected_revision": accepted_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let current_revision_conflict_status = current_revision_conflict.status();
|
|
let current_revision_conflict = current_revision_conflict.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
current_revision_conflict_status,
|
|
reqwest::StatusCode::CONFLICT,
|
|
"body={current_revision_conflict}"
|
|
);
|
|
assert_eq!(
|
|
current_revision_conflict["error"]["code"],
|
|
"onboarding_idempotency_conflict"
|
|
);
|
|
|
|
let stale = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&json!({
|
|
"event": "dismissed",
|
|
"idempotency_key": "onboarding-dismiss-tab-b",
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let stale_status = stale.status();
|
|
let stale = stale.json::<Value>().await.unwrap();
|
|
assert_eq!(stale_status, reqwest::StatusCode::CONFLICT, "body={stale}");
|
|
assert_eq!(stale["error"]["code"], "onboarding_stale_revision");
|
|
|
|
for payload in [
|
|
json!({
|
|
"event": "eligible",
|
|
"idempotency_key": "forged-eligibility",
|
|
"expected_revision": accepted_revision,
|
|
}),
|
|
json!({
|
|
"event": "completed",
|
|
"idempotency_key": "forged-completion",
|
|
"expected_revision": accepted_revision,
|
|
}),
|
|
json!({
|
|
"event": "started",
|
|
"idempotency_key": "forged-step",
|
|
"expected_revision": accepted_revision,
|
|
"completed_steps": ["operation", "first_call"],
|
|
}),
|
|
json!({
|
|
"event": "started",
|
|
"idempotency_key": "onboarding:completed:v1",
|
|
"expected_revision": accepted_revision,
|
|
}),
|
|
] {
|
|
let response = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&payload)
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let status = response.status();
|
|
let body = response.json::<Value>().await.unwrap();
|
|
|
|
assert_eq!(
|
|
status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={body}"
|
|
);
|
|
assert_eq!(body["error"]["code"], "onboarding_event_not_allowed");
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn direct_presentation_mutation_cannot_precede_server_eligibility() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_direct_event");
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let direct = client
|
|
.post(format!("{base_url}/onboarding/events"))
|
|
.json(&json!({
|
|
"event": "started",
|
|
"idempotency_key": "direct-before-snapshot",
|
|
"expected_revision": 0,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let direct_status = direct.status();
|
|
let direct = direct.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
direct_status,
|
|
reqwest::StatusCode::CONFLICT,
|
|
"body={direct}"
|
|
);
|
|
assert_eq!(direct["error"]["code"], "onboarding_stale_revision");
|
|
|
|
let snapshot = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
assert!(snapshot["eligible_since"].as_str().is_some());
|
|
assert_eq!(snapshot["status"], "in_progress");
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn import_context_registration_and_selection_are_revision_guarded() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_select_draft");
|
|
let pool = registry.pool();
|
|
insert_admin_import_fixture(pool).await;
|
|
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let initial = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = initial["revision"].as_i64().unwrap();
|
|
assert!(initial["import_context"].is_null());
|
|
|
|
// Forged identity: no committed immutable apply report.
|
|
let forged = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_missing",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let forged_status = forged.status();
|
|
let forged = forged.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
forged_status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={forged}"
|
|
);
|
|
assert_eq!(
|
|
forged["error"]["code"],
|
|
"onboarding_import_application_unavailable"
|
|
);
|
|
|
|
// Stale revision cannot register a context.
|
|
let stale = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": revision + 1,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let stale_status = stale.status();
|
|
let stale = stale.json::<Value>().await.unwrap();
|
|
assert_eq!(stale_status, reqwest::StatusCode::CONFLICT, "body={stale}");
|
|
assert_eq!(stale["error"]["code"], "onboarding_stale_revision");
|
|
|
|
// A valid registration stores a pending, recoverable import context and
|
|
// suppresses generic automatic Operation selection.
|
|
let registered = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let registered_status = registered.status();
|
|
let registered = registered.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
registered_status,
|
|
reqwest::StatusCode::OK,
|
|
"body={registered}"
|
|
);
|
|
assert_eq!(registered["registered"], true);
|
|
assert_eq!(registered["operation_id"], Value::Null);
|
|
assert_eq!(
|
|
registered["import_context"]["selected_operation_id"],
|
|
Value::Null
|
|
);
|
|
assert_eq!(registered["import_context"]["plan_digest"], "b".repeat(64));
|
|
assert_eq!(
|
|
registered["import_context"]["report"]["schema_version"],
|
|
"import-plan-apply-report-v1"
|
|
);
|
|
assert_eq!(
|
|
registered["import_context"]["choices"][0]["selectable"],
|
|
true
|
|
);
|
|
let registered_revision = registered["revision"].as_i64().unwrap();
|
|
|
|
// Selecting under a different application identity is rejected.
|
|
let mismatched = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_other",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let mismatched_status = mismatched.status();
|
|
let mismatched = mismatched.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
mismatched_status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={mismatched}"
|
|
);
|
|
assert_eq!(
|
|
mismatched["error"]["code"],
|
|
"onboarding_import_context_unavailable"
|
|
);
|
|
|
|
// A forged operation is not a successful outcome of the report.
|
|
let forged = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_forged",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let forged_status = forged.status();
|
|
let forged = forged.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
forged_status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={forged}"
|
|
);
|
|
assert_eq!(
|
|
forged["error"]["code"],
|
|
"onboarding_import_draft_unavailable"
|
|
);
|
|
|
|
// Unknown/raw client fields are rejected outright.
|
|
let unknown = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
"raw_credential": "crk_forbidden_canary",
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let unknown_status = unknown.status();
|
|
let unknown = unknown.text().await.unwrap();
|
|
assert_eq!(
|
|
unknown_status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={unknown}"
|
|
);
|
|
|
|
// A verified choice anchors the exact imported Draft.
|
|
let selected = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let selected_status = selected.status();
|
|
let selected = selected.json::<Value>().await.unwrap();
|
|
assert_eq!(selected_status, reqwest::StatusCode::OK, "body={selected}");
|
|
assert_eq!(selected["selected"], true);
|
|
assert_eq!(selected["operation_id"], "op_admin_import");
|
|
assert_eq!(selected["status"], "in_progress");
|
|
assert_eq!(selected["import_context"]["selected_operation_version"], 1);
|
|
|
|
// Recovery after a fresh GET preserves the explicit selection.
|
|
let recovered = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
recovered["import_context"]["selected_operation_id"],
|
|
"op_admin_import"
|
|
);
|
|
assert_eq!(recovered["import_context"]["selected_operation_version"], 1);
|
|
assert!(recovered["import_context"]["drift"].is_null());
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn onboarding_revision_round_trips_through_js_safe_integer() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_revision_round_trip");
|
|
let pool = registry.pool();
|
|
insert_admin_import_fixture(pool).await;
|
|
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
// Real GET JSON -> browser JS Number -> POST expected_revision CAS. The
|
|
// deterministic SQL mask keeps the revision a safe integer so the value
|
|
// survives the f64 round trip that a browser performs.
|
|
let value = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = value["revision"].as_i64().unwrap();
|
|
assert!(revision >= 0);
|
|
assert!(
|
|
revision <= 9_007_199_254_740_991,
|
|
"revision must stay within Number.MAX_SAFE_INTEGER"
|
|
);
|
|
let js_round_trip = (revision as f64) as i64;
|
|
assert_eq!(
|
|
js_round_trip, revision,
|
|
"revision must round trip through a browser JS Number"
|
|
);
|
|
|
|
let registered = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": js_round_trip,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let registered_status = registered.status();
|
|
let registered = registered.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
registered_status,
|
|
reqwest::StatusCode::OK,
|
|
"body={registered}"
|
|
);
|
|
let registered_revision = registered["revision"].as_i64().unwrap();
|
|
assert!((registered_revision as f64) as i64 == registered_revision);
|
|
|
|
// A stale JS-safe revision is rejected without mutation.
|
|
let stale = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision - 1,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let stale_status = stale.status();
|
|
let stale = stale.json::<Value>().await.unwrap();
|
|
assert_eq!(stale_status, reqwest::StatusCode::CONFLICT, "body={stale}");
|
|
assert_eq!(stale["error"]["code"], "onboarding_stale_revision");
|
|
|
|
let selected = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": (registered_revision as f64) as i64,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let selected_status = selected.status();
|
|
let selected = selected.json::<Value>().await.unwrap();
|
|
assert_eq!(selected_status, reqwest::StatusCode::OK, "body={selected}");
|
|
assert_eq!(selected["selected"], true);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn import_context_snapshot_stays_consistent_when_candidate_changes() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_import_snapshot");
|
|
let pool = registry.pool().clone();
|
|
insert_admin_import_fixture(&pool).await;
|
|
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let initial = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = initial["revision"].as_i64().unwrap();
|
|
|
|
let registered = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let registered_status = registered.status();
|
|
let registered = registered.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
registered_status,
|
|
reqwest::StatusCode::OK,
|
|
"body={registered}"
|
|
);
|
|
let registered_revision = registered["revision"].as_i64().unwrap();
|
|
// Projection revision and import_context come from one authoritative
|
|
// snapshot: the choice is actionable and nothing is selected yet.
|
|
assert_eq!(
|
|
registered["import_context"]["selected_operation_id"],
|
|
Value::Null
|
|
);
|
|
assert_eq!(
|
|
registered["import_context"]["choices"][0]["outcome"],
|
|
"created"
|
|
);
|
|
assert_eq!(
|
|
registered["import_context"]["choices"][0]["selectable"],
|
|
true
|
|
);
|
|
|
|
// The pending candidate becomes non-actionable between requests.
|
|
sqlx::query("update operations set status = 'archived' where id = 'op_admin_import'")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
|
|
let snapshot = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let snapshot_revision = snapshot["revision"].as_i64().unwrap();
|
|
assert_ne!(snapshot_revision, registered_revision);
|
|
// The same response carries the updated revision and matching choices.
|
|
assert_eq!(
|
|
snapshot["import_context"]["choices"][0]["selectable"],
|
|
false
|
|
);
|
|
|
|
let stale = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let stale_status = stale.status();
|
|
let stale = stale.json::<Value>().await.unwrap();
|
|
assert_eq!(stale_status, reqwest::StatusCode::CONFLICT, "body={stale}");
|
|
assert_eq!(stale["error"]["code"], "onboarding_stale_revision");
|
|
|
|
let unavailable = client
|
|
.post(format!("{base_url}/onboarding/select-draft"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": snapshot_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let unavailable_status = unavailable.status();
|
|
let unavailable = unavailable.json::<Value>().await.unwrap();
|
|
assert_eq!(
|
|
unavailable_status,
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"body={unavailable}"
|
|
);
|
|
assert_eq!(
|
|
unavailable["error"]["code"],
|
|
"onboarding_import_draft_unavailable"
|
|
);
|
|
|
|
let selected: Option<String> = sqlx::query_scalar(
|
|
"select selected_operation_id from onboarding_import_selections
|
|
where workspace_id = 'ws_default'",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert!(
|
|
selected.is_none(),
|
|
"rejected selections must not mutate state"
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
|
|
#[serial]
|
|
async fn concurrent_archive_vs_select_draft_rejects_without_mutation() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_concurrent_select");
|
|
let pool = registry.pool().clone();
|
|
insert_admin_import_fixture(&pool).await;
|
|
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let initial = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = initial["revision"].as_i64().unwrap();
|
|
let registered = client
|
|
.post(format!("{base_url}/onboarding/import-context"))
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"expected_revision": revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let registered_revision = registered["revision"].as_i64().unwrap();
|
|
|
|
// Hold the exact candidate row lock while the HTTP selection contends.
|
|
let mut blocker = pool.begin().await.unwrap();
|
|
sqlx::query("select id from operations where workspace_id = $1 and id = $2 for update")
|
|
.bind("ws_default")
|
|
.bind("op_admin_import")
|
|
.fetch_one(&mut *blocker)
|
|
.await
|
|
.unwrap();
|
|
|
|
let select_client = client.clone();
|
|
let select_url = format!("{base_url}/onboarding/select-draft");
|
|
let select_task = tokio::spawn(async move {
|
|
select_client
|
|
.post(select_url)
|
|
.json(&json!({
|
|
"application_idempotency_key": "idem_admin_import",
|
|
"plan_digest": "b".repeat(64),
|
|
"operation_id": "op_admin_import",
|
|
"operation_version": 1,
|
|
"expected_revision": registered_revision,
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
});
|
|
|
|
tokio::time::sleep(std::time::Duration::from_millis(200)).await;
|
|
sqlx::query(
|
|
"update operations set status = 'archived', updated_at = now()
|
|
where workspace_id = 'ws_default' and id = 'op_admin_import'",
|
|
)
|
|
.execute(&mut *blocker)
|
|
.await
|
|
.unwrap();
|
|
blocker.commit().await.unwrap();
|
|
|
|
let response = select_task.await.unwrap();
|
|
let status = response.status();
|
|
let body = response.json::<Value>().await.unwrap();
|
|
assert!(
|
|
status == reqwest::StatusCode::CONFLICT
|
|
|| status == reqwest::StatusCode::UNPROCESSABLE_ENTITY,
|
|
"concurrent archive must reject the selection: status={status} body={body}"
|
|
);
|
|
let selected: Option<String> = sqlx::query_scalar(
|
|
"select selected_operation_id from onboarding_import_selections
|
|
where workspace_id = 'ws_default'",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert!(
|
|
selected.is_none(),
|
|
"rejected selection must not mutate state"
|
|
);
|
|
}
|
|
|
|
async fn insert_admin_import_fixture(pool: &sqlx::PgPool) {
|
|
sqlx::query(
|
|
"insert into operations (
|
|
id, workspace_id, name, display_name, category, protocol, security_level, status,
|
|
current_draft_version, latest_published_version, created_at, updated_at
|
|
) values ('op_admin_import', 'ws_default', 'admin_import', 'Admin Import', 'general',
|
|
'rest', 'standard', 'draft', 1, null, now(), now())",
|
|
)
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"insert into operation_versions (
|
|
operation_id, version, status, target_json, input_schema_json, output_schema_json,
|
|
input_mapping_json, output_mapping_json, execution_config_json,
|
|
tool_description_json, name, display_name, category, protocol, security_level,
|
|
snapshot_provenance, snapshot_observed_at, created_at
|
|
) values ('op_admin_import', 1, 'draft', '{}'::jsonb, '{}'::jsonb, '{}'::jsonb,
|
|
'{}'::jsonb, '{}'::jsonb, '{}'::jsonb, '{}'::jsonb,
|
|
'admin_import', 'Admin Import', 'general', 'rest', 'standard',
|
|
'native_v4', now(), now())",
|
|
)
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"insert into import_plan_applications (
|
|
workspace_id, idempotency_key, plan_id, plan_digest, report, created_at
|
|
) values ('ws_default', 'idem_admin_import', 'plan_admin', $1, $2, now())",
|
|
)
|
|
.bind("b".repeat(64))
|
|
.bind(json!({
|
|
"schema_version": "import-plan-apply-report-v1",
|
|
"status": "applied",
|
|
"source_digest": "c".repeat(64),
|
|
"outcomes": [{
|
|
"key": "candidate_admin",
|
|
"name": "adminImport",
|
|
"outcome": "created",
|
|
"operation_id": "op_admin_import",
|
|
"version": 1,
|
|
}],
|
|
}))
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread")]
|
|
#[serial]
|
|
async fn reset_selection_is_explicit_and_revision_guarded() {
|
|
let registry = test_registry().await;
|
|
let storage_root = test_storage_root("onboarding_reset_selection");
|
|
let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
|
|
let client = authorized_client(&base_url).await;
|
|
|
|
let initial = client
|
|
.get(format!("{base_url}/onboarding"))
|
|
.send()
|
|
.await
|
|
.unwrap()
|
|
.json::<Value>()
|
|
.await
|
|
.unwrap();
|
|
let revision = initial["revision"].as_i64().unwrap();
|
|
|
|
let reset = client
|
|
.post(format!("{base_url}/onboarding/reset-selection"))
|
|
.json(&json!({"expected_revision": revision}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let reset_status = reset.status();
|
|
let reset = reset.json::<Value>().await.unwrap();
|
|
assert_eq!(reset_status, reqwest::StatusCode::OK, "body={reset}");
|
|
assert_eq!(reset["selection_reset"], true);
|
|
assert_ne!(reset["revision"], initial["revision"]);
|
|
assert_eq!(reset["workspace_id"], initial["workspace_id"]);
|
|
|
|
let stale = client
|
|
.post(format!("{base_url}/onboarding/reset-selection"))
|
|
.json(&json!({"expected_revision": revision}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
let stale_status = stale.status();
|
|
let stale = stale.json::<Value>().await.unwrap();
|
|
assert_eq!(stale_status, reqwest::StatusCode::CONFLICT, "body={stale}");
|
|
assert_eq!(stale["error"]["code"], "onboarding_stale_revision");
|
|
|
|
let forged_selection = client
|
|
.post(format!("{base_url}/onboarding/reset-selection"))
|
|
.json(&json!({
|
|
"expected_revision": reset["revision"],
|
|
"operation_id": "op_client_selected",
|
|
}))
|
|
.send()
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
forged_selection.status(),
|
|
reqwest::StatusCode::UNPROCESSABLE_ENTITY
|
|
);
|
|
}
|