add unit tests

Author: DatGuyJonathan

apps/framework-cli/src/framework/core/plan.rs

@@ -740,4 +740,108 @@ mod tests {
         // Compare the tables to ensure they are identical
         assert_eq!(reconciled.tables.values().next().unwrap(), &table);
     }
+
+    #[tokio::test]
+    async fn test_reconcile_preserves_cluster_name() {
+        // Create a test table with a cluster name
+        let mut table = create_test_table("clustered_table");
+        table.cluster_name = Some("test_cluster".to_string());
+
+        // Create mock OLAP client with the table (but cluster_name will be lost in reality)
+        let mut table_from_reality = table.clone();
+        table_from_reality.cluster_name = None; // ClickHouse system.tables doesn't preserve this
+
+        let mock_client = MockOlapClient {
+            tables: vec![table_from_reality],
+        };
+
+        // Create infrastructure map with the table including cluster_name
+        let mut infra_map = InfrastructureMap::default();
+        infra_map
+            .tables
+            .insert(table.id(DEFAULT_DATABASE_NAME), table.clone());
+
+        // Create test project
+        let project = create_test_project();
+
+        let target_table_names = HashSet::new();
+        // Reconcile the infrastructure map
+        let reconciled =
+            reconcile_with_reality(&project, &infra_map, &target_table_names, mock_client)
+                .await
+                .unwrap();
+
+        // The reconciled map should preserve cluster_name from the infra map
+        assert_eq!(reconciled.tables.len(), 1);
+        let reconciled_table = reconciled.tables.values().next().unwrap();
+        assert_eq!(
+            reconciled_table.cluster_name,
+            Some("test_cluster".to_string()),
+            "cluster_name should be preserved from infra map"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_reconcile_with_reality_mismatched_table_preserves_cluster() {
+        // Create a table that exists in both places but with different schemas
+        let mut infra_table = create_test_table("mismatched_table");
+        infra_table.cluster_name = Some("production_cluster".to_string());
+
+        let mut reality_table = create_test_table("mismatched_table");
+        // Reality table has no cluster_name (as ClickHouse doesn't preserve it)
+        reality_table.cluster_name = None;
+        // Add a column difference to make them mismatched
+        reality_table
+            .columns
+            .push(crate::framework::core::infrastructure::table::Column {
+                name: "extra_col".to_string(),
+                data_type: crate::framework::core::infrastructure::table::ColumnType::String,
+                required: true,
+                unique: false,
+                primary_key: false,
+                default: None,
+                annotations: vec![],
+                comment: None,
+                ttl: None,
+            });
+
+        // Create mock OLAP client with the reality table
+        let mock_client = MockOlapClient {
+            tables: vec![reality_table.clone()],
+        };
+
+        // Create infrastructure map with the infra table
+        let mut infra_map = InfrastructureMap::default();
+        infra_map
+            .tables
+            .insert(infra_table.id(DEFAULT_DATABASE_NAME), infra_table.clone());
+
+        // Create test project
+        let project = create_test_project();
+
+        let target_table_names = HashSet::new();
+        // Reconcile the infrastructure map
+        let reconciled =
+            reconcile_with_reality(&project, &infra_map, &target_table_names, mock_client)
+                .await
+                .unwrap();
+
+        // The reconciled map should still have the table
+        assert_eq!(reconciled.tables.len(), 1);
+        let reconciled_table = reconciled.tables.values().next().unwrap();
+
+        // The cluster_name should be preserved from the infra map
+        assert_eq!(
+            reconciled_table.cluster_name,
+            Some("production_cluster".to_string()),
+            "cluster_name should be preserved from infra map even when schema differs"
+        );
+
+        // But the columns should be updated from reality
+        assert_eq!(
+            reconciled_table.columns.len(),
+            reality_table.columns.len(),
+            "columns should be updated from reality"
+        );
+    }
 }

apps/framework-cli/src/framework/core/plan_validator.rs

@@ -85,3 +85,225 @@ pub fn validate(project: &Project, plan: &InfraPlan) -> Result<(), ValidationErr
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::framework::core::infrastructure::table::{Column, ColumnType, OrderBy, Table};
+    use crate::framework::core::infrastructure_map::{
+        InfrastructureMap, PrimitiveSignature, PrimitiveTypes,
+    };
+    use crate::framework::core::partial_infrastructure_map::LifeCycle;
+    use crate::framework::core::plan::InfraPlan;
+    use crate::framework::versions::Version;
+    use crate::infrastructure::olap::clickhouse::config::{ClickHouseConfig, ClusterConfig};
+    use crate::project::{Project, ProjectFeatures};
+    use std::collections::HashMap;
+    use std::path::PathBuf;
+
+    fn create_test_project(clusters: Option<Vec<ClusterConfig>>) -> Project {
+        Project {
+            language: crate::framework::languages::SupportedLanguages::Typescript,
+            redpanda_config: crate::infrastructure::stream::kafka::models::KafkaConfig::default(),
+            clickhouse_config: ClickHouseConfig {
+                db_name: "local".to_string(),
+                user: "default".to_string(),
+                password: "".to_string(),
+                use_ssl: false,
+                host: "localhost".to_string(),
+                host_port: 18123,
+                native_port: 9000,
+                host_data_path: None,
+                additional_databases: vec![],
+                clusters,
+            },
+            http_server_config: crate::cli::local_webserver::LocalWebserverConfig::default(),
+            redis_config: crate::infrastructure::redis::redis_client::RedisConfig::default(),
+            git_config: crate::utilities::git::GitConfig::default(),
+            temporal_config:
+                crate::infrastructure::orchestration::temporal::TemporalConfig::default(),
+            state_config: crate::project::StateConfig::default(),
+            migration_config: crate::project::MigrationConfig::default(),
+            language_project_config: crate::project::LanguageProjectConfig::default(),
+            project_location: PathBuf::from("/test"),
+            is_production: false,
+            supported_old_versions: HashMap::new(),
+            jwt: None,
+            authentication: crate::project::AuthenticationConfig::default(),
+            features: ProjectFeatures::default(),
+            load_infra: None,
+            typescript_config: crate::project::TypescriptConfig::default(),
+            source_dir: crate::project::default_source_dir(),
+        }
+    }
+
+    fn create_test_table(name: &str, cluster_name: Option<String>) -> Table {
+        Table {
+            name: name.to_string(),
+            columns: vec![Column {
+                name: "id".to_string(),
+                data_type: ColumnType::String,
+                required: true,
+                unique: false,
+                primary_key: true,
+                default: None,
+                annotations: vec![],
+                comment: None,
+                ttl: None,
+            }],
+            order_by: OrderBy::Fields(vec!["id".to_string()]),
+            partition_by: None,
+            sample_by: None,
+            engine: None,
+            version: Some(Version::from_string("1.0.0".to_string())),
+            source_primitive: PrimitiveSignature {
+                name: name.to_string(),
+                primitive_type: PrimitiveTypes::DataModel,
+            },
+            metadata: None,
+            life_cycle: LifeCycle::FullyManaged,
+            engine_params_hash: None,
+            table_settings: None,
+            indexes: vec![],
+            database: None,
+            table_ttl_setting: None,
+            cluster_name,
+        }
+    }
+
+    fn create_test_plan(tables: Vec<Table>) -> InfraPlan {
+        let mut table_map = HashMap::new();
+        for table in tables {
+            table_map.insert(format!("local_{}", table.name), table);
+        }
+
+        InfraPlan {
+            target_infra_map: InfrastructureMap {
+                default_database: "local".to_string(),
+                tables: table_map,
+                topics: HashMap::new(),
+                api_endpoints: HashMap::new(),
+                views: HashMap::new(),
+                topic_to_table_sync_processes: HashMap::new(),
+                topic_to_topic_sync_processes: HashMap::new(),
+                function_processes: HashMap::new(),
+                block_db_processes: crate::framework::core::infrastructure::olap_process::OlapProcess {},
+                consumption_api_web_server: crate::framework::core::infrastructure::consumption_webserver::ConsumptionApiWebServer {},
+                orchestration_workers: HashMap::new(),
+                sql_resources: HashMap::new(),
+                workflows: HashMap::new(),
+                web_apps: HashMap::new(),
+            },
+            changes: Default::default(),
+        }
+    }
+
+    #[test]
+    fn test_validate_no_clusters_defined_but_table_references_one() {
+        let project = create_test_project(None);
+        let table = create_test_table("test_table", Some("test_cluster".to_string()));
+        let plan = create_test_plan(vec![table]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_err());
+        match result {
+            Err(ValidationError::ClusterValidation(msg)) => {
+                assert!(msg.contains("test_table"));
+                assert!(msg.contains("test_cluster"));
+                assert!(msg.contains("no clusters are defined"));
+            }
+            _ => panic!("Expected ClusterValidation error"),
+        }
+    }
+
+    #[test]
+    fn test_validate_table_references_undefined_cluster() {
+        let project = create_test_project(Some(vec![
+            ClusterConfig {
+                name: "cluster_a".to_string(),
+            },
+            ClusterConfig {
+                name: "cluster_b".to_string(),
+            },
+        ]));
+        let table = create_test_table("test_table", Some("cluster_c".to_string()));
+        let plan = create_test_plan(vec![table]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_err());
+        match result {
+            Err(ValidationError::ClusterValidation(msg)) => {
+                assert!(msg.contains("test_table"));
+                assert!(msg.contains("cluster_c"));
+                assert!(msg.contains("cluster_a"));
+                assert!(msg.contains("cluster_b"));
+            }
+            _ => panic!("Expected ClusterValidation error"),
+        }
+    }
+
+    #[test]
+    fn test_validate_table_references_valid_cluster() {
+        let project = create_test_project(Some(vec![ClusterConfig {
+            name: "test_cluster".to_string(),
+        }]));
+        let table = create_test_table("test_table", Some("test_cluster".to_string()));
+        let plan = create_test_plan(vec![table]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_validate_table_with_no_cluster_is_allowed() {
+        let project = create_test_project(Some(vec![ClusterConfig {
+            name: "test_cluster".to_string(),
+        }]));
+        let table = create_test_table("test_table", None);
+        let plan = create_test_plan(vec![table]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_validate_multiple_tables_different_clusters() {
+        let project = create_test_project(Some(vec![
+            ClusterConfig {
+                name: "cluster_a".to_string(),
+            },
+            ClusterConfig {
+                name: "cluster_b".to_string(),
+            },
+        ]));
+        let table1 = create_test_table("table1", Some("cluster_a".to_string()));
+        let table2 = create_test_table("table2", Some("cluster_b".to_string()));
+        let plan = create_test_plan(vec![table1, table2]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_validate_empty_clusters_list() {
+        let project = create_test_project(Some(vec![]));
+        let table = create_test_table("test_table", Some("test_cluster".to_string()));
+        let plan = create_test_plan(vec![table]);
+
+        let result = validate(&project, &plan);
+
+        assert!(result.is_err());
+        match result {
+            Err(ValidationError::ClusterValidation(msg)) => {
+                assert!(msg.contains("test_table"));
+                assert!(msg.contains("test_cluster"));
+            }
+            _ => panic!("Expected ClusterValidation error"),
+        }
+    }
+}