databuild/databuild/format_consistency_test.rs

#[cfg(test)]
mod format_consistency_tests {
    use super::*;
    use crate::*;
    use crate::repositories::partitions::PartitionsRepository;
    use crate::event_log::mock::{create_mock_bel_query_engine_with_events, test_events};
    use std::sync::Arc;

    #[tokio::test]
    async fn test_partitions_list_json_format_consistency() {
        // Create test data
        let build_id = "test-build-123".to_string();
        let partition1 = PartitionRef { str: "data/users".to_string() };
        let partition2 = PartitionRef { str: "data/orders".to_string() };
        
        let events = vec![
            test_events::build_request_received(Some(build_id.clone()), vec![partition1.clone(), partition2.clone()]),
            test_events::partition_status(Some(build_id.clone()), partition1.clone(), PartitionStatus::PartitionBuilding, None),
            test_events::partition_status(Some(build_id.clone()), partition1.clone(), PartitionStatus::PartitionAvailable, None),
            test_events::partition_status(Some(build_id.clone()), partition2.clone(), PartitionStatus::PartitionBuilding, None),
            test_events::partition_status(Some(build_id.clone()), partition2.clone(), PartitionStatus::PartitionFailed, None),
        ];
        
        let query_engine = create_mock_bel_query_engine_with_events(events).await.unwrap();
        let repository = PartitionsRepository::new(query_engine);
        
        // Test the new unified protobuf format
        let request = PartitionsListRequest {
            limit: Some(10),
            offset: None,
            status_filter: None,
        };
        
        let response = repository.list_protobuf(request).await.unwrap();
        
        // Serialize to JSON and verify structure
        let json_value = serde_json::to_value(&response).unwrap();
        
        // Verify top-level structure matches expected protobuf schema
        assert!(json_value.get("partitions").is_some());
        assert!(json_value.get("total_count").is_some());
        assert!(json_value.get("has_more").is_some());
        
        let partitions = json_value["partitions"].as_array().unwrap();
        assert_eq!(partitions.len(), 2);
        
        // Verify each partition has dual status fields
        for partition in partitions {
            assert!(partition.get("partition_ref").is_some());
            assert!(partition.get("status_code").is_some(), "Missing status_code field");
            assert!(partition.get("status_name").is_some(), "Missing status_name field");
            assert!(partition.get("last_updated").is_some());
            assert!(partition.get("builds_count").is_some());
            assert!(partition.get("invalidation_count").is_some());
            
            // Verify status fields are consistent
            let status_code = partition["status_code"].as_i64().unwrap();
            let status_name = partition["status_name"].as_str().unwrap();
            
            // Map status codes to expected names
            let expected_name = match status_code {
                1 => "requested",
                2 => "analyzed", 
                3 => "building",
                4 => "available",
                5 => "failed",
                6 => "delegated",
                _ => "unknown",
            };
            
            // Find the partition by status to verify correct mapping
            if status_name == "available" {
                assert_eq!(status_code, 4, "Available status should have code 4");
            } else if status_name == "failed" {
                assert_eq!(status_code, 5, "Failed status should have code 5");
            }
        }
        
        // Verify JSON serialization produces expected field names (snake_case for JSON)
        let json_str = serde_json::to_string_pretty(&response).unwrap();
        assert!(json_str.contains("\"partitions\""));
        assert!(json_str.contains("\"total_count\""));
        assert!(json_str.contains("\"has_more\""));
        assert!(json_str.contains("\"partition_ref\""));
        assert!(json_str.contains("\"status_code\""));
        assert!(json_str.contains("\"status_name\""));
        assert!(json_str.contains("\"last_updated\""));
        assert!(json_str.contains("\"builds_count\""));
        assert!(json_str.contains("\"invalidation_count\""));
        
        println!("✅ Partitions list JSON format test passed");
        println!("Sample JSON output:\n{}", json_str);
    }

    #[tokio::test]
    async fn test_status_conversion_utilities() {
        use crate::status_utils::*;
        
        // Test PartitionStatus conversions
        let status = PartitionStatus::PartitionAvailable;
        assert_eq!(status.to_display_string(), "available");
        assert_eq!(PartitionStatus::from_display_string("available"), Some(status));
        
        // Test JobStatus conversions  
        let job_status = JobStatus::JobCompleted;
        assert_eq!(job_status.to_display_string(), "completed");
        assert_eq!(JobStatus::from_display_string("completed"), Some(job_status));
        
        // Test BuildRequestStatus conversions
        let build_status = BuildRequestStatus::BuildRequestCompleted;
        assert_eq!(build_status.to_display_string(), "completed");
        assert_eq!(BuildRequestStatus::from_display_string("completed"), Some(build_status));
        
        // Test invalid conversions
        assert_eq!(PartitionStatus::from_display_string("invalid"), None);
        
        println!("✅ Status conversion utilities test passed");
    }

    #[test]
    fn test_protobuf_response_helper_functions() {
        use crate::status_utils::list_response_helpers::*;
        
        // Test PartitionSummary creation
        let summary = create_partition_summary(
            PartitionRef { str: "test/partition".to_string() },
            PartitionStatus::PartitionAvailable,
            1234567890,
            5,
            2,
            Some("build-123".to_string()),
        );
        
        assert_eq!(summary.partition_ref, Some(PartitionRef { str: "test/partition".to_string() }));
        assert_eq!(summary.status_code, 4); // PartitionAvailable = 4
        assert_eq!(summary.status_name, "available");
        assert_eq!(summary.last_updated, 1234567890);
        assert_eq!(summary.builds_count, 5);
        assert_eq!(summary.invalidation_count, 2);
        assert_eq!(summary.last_successful_build, Some("build-123".to_string()));
        
        println!("✅ Protobuf response helper functions test passed");
    }
}