use super::*; use admin_api::error::ApiError; use crank_artifacts::MAX_ARTIFACT_BYTES; use crank_core::HttpMethod; #[derive(Debug, PartialEq, Eq)] struct CatalogCounts { operations: i64, operation_versions: i64, auth_profiles: i64, agent_operation_bindings: i64, } async fn catalog_counts( registry: &crank_registry::PostgresRegistry, workspace_id: &WorkspaceId, ) -> CatalogCounts { let (operations, operation_versions, auth_profiles, agent_operation_bindings) = sqlx::query_as::<_, (i64, i64, i64, i64)>( "select (select count(*) from operations where workspace_id = $1), (select count(*) from operation_versions ov join operations o on o.id = ov.operation_id where o.workspace_id = $1), (select count(*) from auth_profiles where workspace_id = $1), (select count(*) from agent_operation_bindings b join operations o on o.id = b.operation_id where o.workspace_id = $1)", ) .bind(workspace_id.as_str()) .fetch_one(registry.pool()) .await .unwrap(); CatalogCounts { operations, operation_versions, auth_profiles, agent_operation_bindings, } } fn upload(bytes: Vec) -> OpenApiUpload { OpenApiUpload { bytes, mime_type: "application/json".to_owned(), locale: OpenApiUploadLocale::En, } } const PREVIEWABLE_DOCUMENT: &[u8] = br#"{ "openapi":"3.0.3", "info":{"title":"Preview lifecycle","version":"1"}, "paths":{"/ready":{"get":{"responses":{"200":{"description":"ok"}}}}} }"#; async fn insert_malformed_auth_profile( registry: &crank_registry::PostgresRegistry, workspace_id: &WorkspaceId, ) { sqlx::query( "insert into auth_profiles (id, workspace_id, name, kind, config_json, created_at, updated_at) values ('auth_decode_failure', $1, 'decode-failure', 'bearer', 'null'::jsonb, now(), now())", ) .bind(workspace_id.as_str()) .execute(registry.pool()) .await .unwrap(); } async fn insert_catalog_overflow( registry: &crank_registry::PostgresRegistry, workspace_id: &WorkspaceId, ) { sqlx::query( "insert into operations (id, workspace_id, name, display_name, protocol, status, created_at, updated_at) select 'op_catalog_' || g, $1, 'catalog_op_' || g, 'Catalog Op ' || g, 'rest', 'draft', now(), now() from generate_series(1, 10001) as g", ) .bind(workspace_id.as_str()) .execute(registry.pool()) .await .unwrap(); } async fn durable_import_jobs( registry: &crank_registry::PostgresRegistry, workspace_id: &WorkspaceId, ) -> i64 { sqlx::query_scalar("select count(*) from import_jobs where workspace_id = $1") .bind(workspace_id.as_str()) .fetch_one(registry.pool()) .await .unwrap() } async fn active_artifact_sources( registry: &crank_registry::PostgresRegistry, workspace_id: &WorkspaceId, ) -> i64 { sqlx::query_scalar( "select count(*) from artifact_sources where workspace_id = $1 and lifecycle = 'active'", ) .bind(workspace_id.as_str()) .fetch_one(registry.pool()) .await .unwrap() } fn assert_upload_error(error: ApiError, variant: &str, code: &str) { let context = match (variant, error) { ("validation", ApiError::Validation { context, .. }) => context, ("payload_too_large", ApiError::PayloadTooLarge { context, .. }) => context, (expected, actual) => panic!("expected {expected} error, got {actual:?}"), } .expect("OpenAPI upload errors carry a machine-readable code"); assert_eq!(context["error_code"], format!("openapi_upload.{code}")); } #[tokio::test] #[serial] async fn preview_outcomes_do_not_mutate_operation_catalog() { let registry = test_registry().await; let service = test_service( registry.clone(), test_storage_root("openapi_upload_outcomes"), test_auth_settings(), test_secret_crypto(), ); let workspace_id = WorkspaceId::new("ws_default"); let before = catalog_counts(®istry, &workspace_id).await; let preview = service .preview_openapi_import( &workspace_id, upload( br#"{ "openapi":"3.0.3", "info":{"title":"Upload outcomes","version":"1"}, "paths":{"/ready":{"get":{"responses":{"200":{"description":"ok"}}}}} }"# .to_vec(), ), ) .await .expect("valid OpenAPI document should return a preview"); let candidates = preview .preview .groups .iter() .flat_map(|group| &group.operations) .collect::>(); assert_eq!(candidates.len(), 1); assert_eq!(candidates[0].method, HttpMethod::Get); assert_eq!(candidates[0].path, "/ready"); assert_eq!(candidates[0].key, "GET /ready"); assert_eq!(catalog_counts(®istry, &workspace_id).await, before); let before = catalog_counts(®istry, &workspace_id).await; let error = service .preview_openapi_import(&workspace_id, upload(Vec::new())) .await .expect_err("empty upload should be rejected"); assert_upload_error(error, "validation", "empty_file"); assert_eq!(catalog_counts(®istry, &workspace_id).await, before); let before = catalog_counts(®istry, &workspace_id).await; let error = service .preview_openapi_import(&workspace_id, upload(b"{".to_vec())) .await .expect_err("malformed OpenAPI document should be rejected"); assert_upload_error(error, "validation", "invalid_document"); assert_eq!(catalog_counts(®istry, &workspace_id).await, before); let before = catalog_counts(®istry, &workspace_id).await; let error = service .preview_openapi_import(&workspace_id, upload(vec![b' '; MAX_ARTIFACT_BYTES + 1])) .await .expect_err("oversized upload should be rejected"); assert_upload_error(error, "payload_too_large", "file_too_large"); assert_eq!(catalog_counts(®istry, &workspace_id).await, before); let before = catalog_counts(®istry, &workspace_id).await; let error = service .preview_openapi_import( &workspace_id, upload( br#"{ "openapi":"3.0.3", "info":{"title":"No methods","version":"1"}, "paths":{} }"# .to_vec(), ), ) .await .expect_err("document without supported methods should be rejected"); assert_upload_error(error, "validation", "no_methods"); assert_eq!(catalog_counts(®istry, &workspace_id).await, before); } #[tokio::test] #[serial] async fn preview_profile_decode_failure_leaves_no_pending_job_or_source() { let registry = test_registry().await; let service = test_service( registry.clone(), test_storage_root("openapi_upload_profile_decode_failure"), test_auth_settings(), test_secret_crypto(), ); let workspace_id = WorkspaceId::new("ws_default"); insert_malformed_auth_profile(®istry, &workspace_id).await; service .preview_openapi_import(&workspace_id, upload(PREVIEWABLE_DOCUMENT.to_vec())) .await .expect_err("malformed auth profile must fail preview enrichment"); assert_eq!( durable_import_jobs(®istry, &workspace_id).await, 0, "profile lookup failure must not leave a durable import job" ); assert_eq!( active_artifact_sources(®istry, &workspace_id).await, 0, "profile lookup failure must not leave attached sources" ); } #[tokio::test] #[serial] async fn preview_catalog_limit_failure_leaves_no_pending_job_or_source() { let registry = test_registry().await; let service = test_service( registry.clone(), test_storage_root("openapi_upload_catalog_limit_failure"), test_auth_settings(), test_secret_crypto(), ); let workspace_id = WorkspaceId::new("ws_default"); insert_catalog_overflow(®istry, &workspace_id).await; service .preview_openapi_import(&workspace_id, upload(PREVIEWABLE_DOCUMENT.to_vec())) .await .expect_err("catalog over the import limit must fail preview enrichment"); assert_eq!( durable_import_jobs(®istry, &workspace_id).await, 0, "catalog lookup failure must not leave a durable import job" ); assert_eq!( active_artifact_sources(®istry, &workspace_id).await, 0, "catalog lookup failure must not leave attached sources" ); }