0.0.4-alpha.2

crates/knowledge-store-postgres-lib/tests/postgres_migration.rs

@@ -0,0 +1,88 @@
+// file: crates/knowledge-store-postgres-lib/tests/postgres_migration.rs
+// version: 1
+
+fn test_schema_name() -> String {
+    let elapsed = match std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) {
+        Ok(value) => value,
+        Err(_) => return format!("knowledge_test_{}", std::process::id()),
+    };
+    return format!("knowledge_test_{}_{}", std::process::id(), elapsed.as_nanos());
+}
+
+fn database_url_with_search_path(database_url: &str, schema: &str) -> String {
+    let separator = if database_url.contains('?') { '&' } else { '?' };
+    return format!("{database_url}{separator}options=-c%20search_path%3D{schema}");
+}
+
+async fn connect(database_url: &str) -> Option<tokio_postgres::Client> {
+    let connection_result = tokio_postgres::connect(database_url, tokio_postgres::NoTls).await;
+    assert!(connection_result.is_ok(), "test PostgreSQL connection failed");
+    let (client, connection) = match connection_result {
+        Ok(value) => value,
+        Err(_) => return None,
+    };
+    let _connection_task = tokio::spawn(async move {
+        let _connection_result = connection.await;
+        return;
+    });
+    return Some(client);
+}
+
+#[tokio::test]
+#[ignore = "requires KNOWLEDGE_POSTGRES_TEST_URL"]
+async fn initial_migration_runs_in_isolated_schema() {
+    let database_url_result = std::env::var("KNOWLEDGE_POSTGRES_TEST_URL");
+    assert!(database_url_result.is_ok(), "KNOWLEDGE_POSTGRES_TEST_URL is required");
+    let database_url = match database_url_result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    let schema = test_schema_name();
+    let admin = match connect(database_url.as_str()).await {
+        Some(value) => value,
+        None => return,
+    };
+    let create_schema = format!("CREATE SCHEMA {schema}");
+    let create_result = admin.batch_execute(create_schema.as_str()).await;
+    assert!(create_result.is_ok(), "isolated PostgreSQL schema creation failed");
+    if create_result.is_err() {
+        return;
+    }
+    let isolated_url = database_url_with_search_path(database_url.as_str(), schema.as_str());
+    let config_result = knowledge_store_postgres_lib::PostgresStoreConfig::new(isolated_url.as_str(), 2);
+    assert!(config_result.is_ok(), "PostgreSQL store configuration failed");
+    let config = match config_result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    let store_result = knowledge_store_postgres_lib::PostgresStore::new(config);
+    assert!(store_result.is_ok(), "PostgreSQL store construction failed");
+    let store = match store_result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    let migration_result = store.apply_migrations().await;
+    assert!(migration_result.is_ok(), "initial PostgreSQL migration failed");
+    let table_result = admin
+        .query(
+            "SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_name IN ('knowledge_sources', 'knowledge_source_sync_state', 'refinery_schema_history') ORDER BY table_name",
+            &[&schema],
+        )
+        .await;
+    assert!(table_result.is_ok(), "PostgreSQL migration verification query failed");
+    let table_rows = match table_result {
+        Ok(value) => value,
+        Err(_) => return,
+    };
+    assert_eq!(table_rows.len(), 3);
+    if table_rows.len() == 3 {
+        assert_eq!(table_rows[0].get::<usize, &str>(0), "knowledge_source_sync_state");
+        assert_eq!(table_rows[1].get::<usize, &str>(0), "knowledge_sources");
+        assert_eq!(table_rows[2].get::<usize, &str>(0), "refinery_schema_history");
+    }
+    drop(store);
+    let drop_schema = format!("DROP SCHEMA {schema} CASCADE");
+    let drop_result = admin.batch_execute(drop_schema.as_str()).await;
+    assert!(drop_result.is_ok(), "isolated PostgreSQL schema cleanup failed");
+    return;
+}