api: add structured context for service errors

apps/admin-api/src/app.rs

@@ -221,18 +221,19 @@ mod tests {
     use axum::{Json, Router, routing::post};
     use crank_adapter_grpc::test_support as grpc_test_support;
     use crank_core::{
-        DescriptorId, ExecutionConfig, ExecutionMode, GraphqlOperationType, GraphqlTarget,
-        GrpcTarget, HttpMethod, MembershipRole, Protocol, RestTarget, SecretKind, SoapBindingStyle,
-        SoapOperationMetadata, SoapTarget, SoapVersion, Target, ToolDescription, TransportBehavior,
-        WorkspaceId,
+        AsyncJobHandle, AsyncJobId, DescriptorId, ExecutionConfig, ExecutionMode,
+        GraphqlOperationType, GraphqlTarget, GrpcTarget, HttpMethod, JobStatus, MembershipRole,
+        OperationId, Protocol, RestTarget, SecretKind, SoapBindingStyle, SoapOperationMetadata,
+        SoapTarget, SoapVersion, Target, ToolDescription, TransportBehavior, WorkspaceId,
     };
     use crank_mapping::{MappingRule, MappingSet};
-    use crank_registry::PostgresRegistry;
+    use crank_registry::{CreateAsyncJobRequest, PostgresRegistry};
     use crank_runtime::SecretCrypto;
     use crank_schema::{Schema, SchemaKind};
     use serde_json::{Value, json};
     use serial_test::serial;
     use sqlx::{Connection, Executor, PgConnection};
+    use time::OffsetDateTime;
     use tokio::net::TcpListener;
 
     use crate::{
@@ -1613,6 +1614,69 @@ mod tests {
         assert_eq!(result["id"], "lead_123");
     }
 
+    #[tokio::test(flavor = "multi_thread")]
+    #[serial]
+    async fn returns_structured_context_for_pending_async_job_result() {
+        let registry = test_registry().await;
+        let storage_root = test_storage_root("async_job_pending_result");
+        let upstream_base_url = spawn_upstream_server().await;
+        let job_id = AsyncJobId::new("job_pending_result".to_owned());
+        let base_url = spawn_admin_api(build_test_app(registry.clone(), storage_root)).await;
+        let client = authorized_client(&base_url).await;
+        let created = client
+            .post(format!("{base_url}/operations"))
+            .json(&test_rest_async_job_operation_payload(
+                &upstream_base_url,
+                "crm_async_job_pending_result",
+            ))
+            .send()
+            .await
+            .unwrap()
+            .json::<Value>()
+            .await
+            .unwrap();
+        let operation_id = OperationId::new(created["operation_id"].as_str().unwrap().to_owned());
+        let now = OffsetDateTime::now_utc();
+        registry
+            .create_async_job(CreateAsyncJobRequest {
+                job: &AsyncJobHandle {
+                    id: job_id.clone(),
+                    workspace_id: WorkspaceId::new(DEFAULT_WORKSPACE_ID),
+                    agent_id: None,
+                    operation_id,
+                    status: JobStatus::Running,
+                    progress: json!({ "pct": 25 }),
+                    result: None,
+                    error: None,
+                    expires_at: Some(now + time::Duration::minutes(5)),
+                    created_at: now,
+                    updated_at: now,
+                    finished_at: None,
+                },
+            })
+            .await
+            .unwrap();
+
+        let response = client
+            .get(format!("{base_url}/async-jobs/{}/result", job_id.as_str()))
+            .send()
+            .await
+            .unwrap();
+        let status = response.status();
+        let body = response.json::<Value>().await.unwrap();
+
+        assert_eq!(status, reqwest::StatusCode::CONFLICT);
+        assert_eq!(body["error"]["code"], "conflict");
+        assert_eq!(body["error"]["message"], "async job result is not ready");
+        assert_eq!(
+            body["error"]["context"],
+            json!({
+                "job_id": job_id.as_str(),
+                "status": "running"
+            })
+        );
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     #[serial]
     async fn uploads_wsdl_and_tests_soap_operation() {
@@ -1684,6 +1748,52 @@ mod tests {
         assert_eq!(test_run["response_preview"]["id"], "lead_123");
     }
 
+    #[tokio::test(flavor = "multi_thread")]
+    #[serial]
+    async fn returns_structured_context_when_wsdl_is_missing() {
+        let registry = test_registry().await;
+        let storage_root = test_storage_root("soap_missing_wsdl");
+        let endpoint = spawn_soap_server().await;
+        let base_url = spawn_admin_api(build_test_app(registry, storage_root)).await;
+        let client = authorized_client(&base_url).await;
+
+        let created = client
+            .post(format!("{base_url}/operations"))
+            .json(&test_soap_operation_payload(
+                &endpoint,
+                "crm_create_lead_soap_missing_wsdl",
+            ))
+            .send()
+            .await
+            .unwrap()
+            .json::<Value>()
+            .await
+            .unwrap();
+        let operation_id = created["operation_id"].as_str().unwrap().to_owned();
+
+        let response = client
+            .get(format!(
+                "{base_url}/operations/{operation_id}/soap/services"
+            ))
+            .send()
+            .await
+            .unwrap();
+        let status = response.status();
+        let body = response.json::<Value>().await.unwrap();
+
+        assert_eq!(status, reqwest::StatusCode::NOT_FOUND);
+        assert_eq!(body["error"]["code"], "not_found");
+        assert_eq!(body["error"]["message"], "wsdl was not uploaded");
+        assert_eq!(
+            body["error"]["context"],
+            json!({
+                "operation_id": operation_id,
+                "version": 1,
+                "descriptor_kind": "wsdl_upload"
+            })
+        );
+    }
+
     #[tokio::test(flavor = "multi_thread")]
     #[serial]
     async fn manages_auth_profiles_and_yaml_upsert() {