Files
crank/apps/admin-api/tests/integration/onboarding.rs
bsodfather ad23cd9a46
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
fix(import): подтвердить обязательные гарантии второго эпика
2026-10-10 13:25:05 +03:00

894 lines
29 KiB
Rust

#![allow(dead_code, unused_imports)]
use super::common::*;
use serde_json::{Value, json};
use serial_test::serial;
mod replay;
mod telemetry;
mod telemetry_startup;
#[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
);
}