test: expand integration scenario coverage (#42)

* test: expand integration scenario coverage

* test: add databases_lifecycle scenario

* fix(test): use service provider in embedding_providers_crud

* test: add managed_tables_lifecycle scenario

* test: poll get_table_profile for async sync in managed_tables_lifecycle

* test: refresh-then-profile in managed_tables_lifecycle

* test: drop managed_tables_lifecycle pending scenario-definition fix

* test: add managed_tables_lifecycle (corrected per fixed scenario)

Author: zfarrell

tests/common/mod.rs

@@ -173,3 +173,19 @@ pub async fn shared_database_id(client: &Client) -> String {
         .expect("create_database should succeed");
     created.id
 }
+
+/// Create a fresh, uniquely-named `sdkci-*` database and return its id.
+///
+/// Unlike [`shared_database_id`], this is for scenarios that exercise the
+/// database lifecycle itself (contexts, catalog attach/detach) and tear the
+/// database back down at the end. The `sdkci-` prefix keeps any leak
+/// identifiable to the nightly sweep if the test panics before cleanup.
+pub async fn create_scratch_database(client: &Client, scenario: &str) -> String {
+    use hotdata::apis::databases_api;
+    let mut request = hotdata::models::CreateDatabaseRequest::new();
+    request.name = Some(Some(sdkci_name(scenario)));
+    let created = databases_api::create_database(client.configuration(), request)
+        .await
+        .expect("create_database should succeed");
+    created.id
+}

tests/connection_types_read.rs

@@ -0,0 +1,50 @@
+//! Scenario: connection_types_read.
+//!
+//! Defined in www.hotdata.dev/api/test-scenarios.yaml — read-only. list_connection_types
+//! returns the connector catalog, and get_connection_type fetches one by name
+//! with its config schema. No fixtures created.
+
+mod common;
+
+use hotdata::apis::connection_types_api;
+
+#[tokio::test]
+async fn connection_types_read() {
+    let client = skip_if_no_creds!();
+    let config = client.configuration();
+
+    let listing = connection_types_api::list_connection_types(config)
+        .await
+        .expect("list_connection_types should succeed");
+    assert!(
+        !listing.connection_types.is_empty(),
+        "expected a non-empty connector catalog"
+    );
+    for ct in &listing.connection_types {
+        assert!(!ct.name.is_empty(), "connection type missing a name");
+        assert!(
+            !ct.label.is_empty(),
+            "connection type {} missing a label",
+            ct.name
+        );
+    }
+
+    // Fetch one by name and confirm the detail echoes the catalog entry.
+    let first = &listing.connection_types[0];
+    let detail = connection_types_api::get_connection_type(config, &first.name)
+        .await
+        .expect("get_connection_type should succeed");
+    assert_eq!(detail.name, first.name);
+    assert_eq!(detail.label, first.label);
+
+    // A fabricated connector name must not resolve to a real type.
+    let bogus = connection_types_api::get_connection_type(config, "sdkci-not-a-connector").await;
+    match bogus {
+        Err(err) => assert_eq!(
+            common::status_of(&err),
+            Some(404),
+            "expected 404 for an unknown connection type, got {err:?}"
+        ),
+        Ok(_) => panic!("get_connection_type should 404 for an unknown connector name"),
+    }
+}

tests/database_catalogs_attach.rs

@@ -0,0 +1,62 @@
+//! Scenario: database_catalogs_attach.
+//!
+//! Defined in www.hotdata.dev/api/test-scenarios.yaml — create a scratch
+//! database, attach the seeded connection as a catalog (with an alias), confirm
+//! it's reachable via the database's attachments, then detach it and delete the
+//! database. Reversible and idempotent — never mutates the connection itself.
+
+mod common;
+
+use hotdata::apis::databases_api;
+use hotdata::models;
+
+#[tokio::test]
+async fn database_catalogs_attach() {
+    let (client, connection_id) = skip_if_no_connection!();
+    let config = client.configuration();
+
+    let database_id = common::create_scratch_database(&client, "dbcat-attach").await;
+    let alias = "sdkci_catalog";
+
+    let mut attach = models::AttachDatabaseCatalogRequest::new(connection_id.clone());
+    attach.alias = Some(Some(alias.to_string()));
+    databases_api::attach_database_catalog(config, &database_id, attach)
+        .await
+        .expect("attach_database_catalog should succeed");
+
+    let attached = databases_api::get_database(config, &database_id)
+        .await
+        .expect("get_database should succeed after attach");
+    let found = attached
+        .attachments
+        .iter()
+        .find(|a| a.connection_id == connection_id);
+    let found = found.unwrap_or_else(|| {
+        panic!("attached connection {connection_id} not present in database attachments")
+    });
+    assert_eq!(
+        found.alias.as_ref().and_then(|a| a.as_deref()),
+        Some(alias),
+        "attachment alias should round-trip"
+    );
+
+    databases_api::detach_database_catalog(config, &database_id, &connection_id)
+        .await
+        .expect("detach_database_catalog should succeed");
+
+    let detached = databases_api::get_database(config, &database_id)
+        .await
+        .expect("get_database should succeed after detach");
+    assert!(
+        !detached
+            .attachments
+            .iter()
+            .any(|a| a.connection_id == connection_id),
+        "connection {connection_id} should be gone from attachments after detach"
+    );
+
+    // Tear down the scratch database.
+    databases_api::delete_database(config, &database_id)
+        .await
+        .expect("delete_database should succeed");
+}

tests/database_contexts_crud.rs

@@ -0,0 +1,90 @@
+//! Scenario: database_contexts_crud.
+//!
+//! Defined in www.hotdata.dev/api/test-scenarios.yaml — create a scratch
+//! database, upsert a named context document, read it back, confirm it appears
+//! in list_database_contexts, delete the context, then delete the database.
+//! Upserting the same name twice verifies replace-on-write.
+
+mod common;
+
+use hotdata::apis::{database_context_api, databases_api};
+use hotdata::models;
+
+#[tokio::test]
+async fn database_contexts_crud() {
+    let client = skip_if_no_creds!();
+    let config = client.configuration();
+
+    let database_id = common::create_scratch_database(&client, "dbctx-crud").await;
+    let context_name = "sdkci_context";
+
+    // Initial upsert.
+    let initial = database_context_api::upsert_database_context(
+        config,
+        &database_id,
+        models::UpsertDatabaseContextRequest::new(
+            "first revision".to_string(),
+            context_name.to_string(),
+        ),
+    )
+    .await
+    .expect("upsert_database_context (create) should succeed");
+    assert_eq!(initial.context.name, context_name);
+    assert_eq!(initial.context.content, "first revision");
+
+    // Upsert the same name again — replace-on-write, not a duplicate.
+    database_context_api::upsert_database_context(
+        config,
+        &database_id,
+        models::UpsertDatabaseContextRequest::new(
+            "second revision".to_string(),
+            context_name.to_string(),
+        ),
+    )
+    .await
+    .expect("upsert_database_context (replace) should succeed");
+
+    let fetched = database_context_api::get_database_context(config, &database_id, context_name)
+        .await
+        .expect("get_database_context should succeed");
+    assert_eq!(fetched.context.name, context_name);
+    assert_eq!(
+        fetched.context.content, "second revision",
+        "upsert with an existing name should replace the content"
+    );
+
+    let listing = database_context_api::list_database_contexts(config, &database_id)
+        .await
+        .expect("list_database_contexts should succeed");
+    let matches: Vec<_> = listing
+        .contexts
+        .iter()
+        .filter(|c| c.name == context_name)
+        .collect();
+    assert_eq!(
+        matches.len(),
+        1,
+        "expected exactly one context named {context_name} (replace, not append), got {}",
+        matches.len()
+    );
+
+    database_context_api::delete_database_context(config, &database_id, context_name)
+        .await
+        .expect("delete_database_context should succeed");
+
+    let after_delete =
+        database_context_api::get_database_context(config, &database_id, context_name).await;
+    match after_delete {
+        Err(err) => assert_eq!(
+            common::status_of(&err),
+            Some(404),
+            "expected 404 after context delete, got {err:?}"
+        ),
+        Ok(_) => panic!("get_database_context should fail with 404 after delete"),
+    }
+
+    // Tear down the scratch database.
+    databases_api::delete_database(config, &database_id)
+        .await
+        .expect("delete_database should succeed");
+}

tests/databases_lifecycle.rs

@@ -0,0 +1,78 @@
+//! Scenario: databases_lifecycle.
+//!
+//! Defined in www.hotdata.dev/api/test-scenarios.yaml — create a database
+//! (metadata-only grouping), read it, confirm it appears in list_databases,
+//! declare a schema and a table on its managed catalog, then delete it and
+//! verify it's gone.
+
+mod common;
+
+use hotdata::apis::databases_api;
+use hotdata::models;
+
+#[tokio::test]
+async fn databases_lifecycle() {
+    let client = skip_if_no_creds!();
+    let config = client.configuration();
+
+    // A uniquely-named sdkci-* database we create and tear down here.
+    let database_id = common::create_scratch_database(&client, "databases-lifecycle").await;
+
+    let fetched = databases_api::get_database(config, &database_id)
+        .await
+        .expect("get_database should succeed");
+    assert_eq!(fetched.id, database_id);
+
+    let listing = databases_api::list_databases(config)
+        .await
+        .expect("list_databases should succeed");
+    assert!(
+        listing.databases.iter().any(|d| d.id == database_id),
+        "created database {database_id} not present in list_databases"
+    );
+
+    // Declare a schema on the database's managed catalog. Identifiers are
+    // SQL-scoped, so use underscore-only names (the database is unique per run,
+    // so a fixed schema/table name can't collide across tests).
+    let schema_name = "sdkci_schema";
+    let schema = databases_api::add_database_schema(
+        config,
+        &database_id,
+        models::AddManagedSchemaRequest::new(schema_name.to_string()),
+    )
+    .await
+    .expect("add_database_schema should succeed");
+    assert_eq!(schema.schema, schema_name);
+    assert!(
+        !schema.connection_id.is_empty(),
+        "schema should report its managed-catalog connection"
+    );
+
+    // Declare a table on that schema.
+    let table_name = "sdkci_table";
+    let table = databases_api::add_database_table(
+        config,
+        &database_id,
+        schema_name,
+        models::AddManagedTableRequest::new(table_name.to_string()),
+    )
+    .await
+    .expect("add_database_table should succeed");
+    assert_eq!(table.table, table_name);
+    assert_eq!(table.schema, schema_name);
+
+    // Delete the database and assert it's gone.
+    databases_api::delete_database(config, &database_id)
+        .await
+        .expect("delete_database should succeed");
+
+    let after_delete = databases_api::get_database(config, &database_id).await;
+    match after_delete {
+        Err(err) => assert_eq!(
+            common::status_of(&err),
+            Some(404),
+            "expected 404 after delete, got {err:?}"
+        ),
+        Ok(_) => panic!("get_database should fail with 404 after delete"),
+    }
+}

tests/embedding_providers_crud.rs

@@ -0,0 +1,79 @@
+//! Scenario: embedding_providers_crud.
+//!
+//! Defined in www.hotdata.dev/api/test-scenarios.yaml — register an embedding
+//! provider, read it, confirm it appears in list_embedding_providers, update it,
+//! then delete it.
+//!
+//! Uses a `service` provider with **no** api_key/secret_name (not `local` — the
+//! runtime currently rejects `local` as "not yet supported"). A service
+//! provider's key is only consulted when embeddings are actually generated, never
+//! at create/get/update, so this exercises the full CRUD surface without any real
+//! external credential and without auto-creating a secret that would need cleanup.
+
+mod common;
+
+use hotdata::apis::embedding_providers_api;
+use hotdata::models;
+
+#[tokio::test]
+async fn embedding_providers_crud() {
+    let client = skip_if_no_creds!();
+    let config = client.configuration();
+
+    // Provider names follow the same underscore-normalized convention as secrets.
+    let name = common::sdkci_name("embprov-crud").replace('-', "_");
+    let renamed = format!("{name}_renamed");
+
+    let mut create_req =
+        models::CreateEmbeddingProviderRequest::new(name.clone(), "service".to_string());
+    create_req.config = Some(Some(
+        serde_json::json!({ "model": "text-embedding-3-small" }),
+    ));
+    let created = embedding_providers_api::create_embedding_provider(config, create_req)
+        .await
+        .expect("create_embedding_provider should succeed");
+    assert_eq!(created.name, name);
+    assert_eq!(created.provider_type, "service");
+    assert!(!created.id.is_empty(), "created provider must have an id");
+
+    let fetched = embedding_providers_api::get_embedding_provider(config, &created.id)
+        .await
+        .expect("get_embedding_provider should succeed");
+    assert_eq!(fetched.id, created.id);
+    assert_eq!(fetched.name, name);
+    assert_eq!(fetched.provider_type, "service");
+
+    let listing = embedding_providers_api::list_embedding_providers(config)
+        .await
+        .expect("list_embedding_providers should succeed");
+    assert!(
+        listing
+            .embedding_providers
+            .iter()
+            .any(|p| p.id == created.id),
+        "created provider {} not present in list_embedding_providers",
+        created.id
+    );
+
+    let mut update = models::UpdateEmbeddingProviderRequest::new();
+    update.name = Some(Some(renamed.clone()));
+    let updated = embedding_providers_api::update_embedding_provider(config, &created.id, update)
+        .await
+        .expect("update_embedding_provider should succeed");
+    assert_eq!(updated.id, created.id);
+    assert_eq!(updated.name, renamed);
+
+    embedding_providers_api::delete_embedding_provider(config, &created.id)
+        .await
+        .expect("delete_embedding_provider should succeed");
+
+    let after_delete = embedding_providers_api::get_embedding_provider(config, &created.id).await;
+    match after_delete {
+        Err(err) => assert_eq!(
+            common::status_of(&err),
+            Some(404),
+            "expected 404 after delete, got {err:?}"
+        ),
+        Ok(_) => panic!("get_embedding_provider should fail with 404 after delete"),
+    }
+}