#![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::().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![ "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::() .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::() .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::().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::().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::().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::().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::().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::().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::().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::() .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::() .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::().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::().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::().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::().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::().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::().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::() .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::() .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::().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::().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::().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::() .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::().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::() .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::().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::().await.unwrap(); assert_eq!( unavailable_status, reqwest::StatusCode::UNPROCESSABLE_ENTITY, "body={unavailable}" ); assert_eq!( unavailable["error"]["code"], "onboarding_import_draft_unavailable" ); let selected: Option = 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::() .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::() .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::().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 = 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::() .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::().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::().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 ); }