cckit 0.1.0

#[cfg(test)]
mod integration_tests {
    use crate::models::ModelProvider;
    use crate::providers::{PROVIDER_CONFIGS, find_provider_config, get_provider_info, get_supported_providers};

    #[test]
    fn test_provider_configs_defined() {
        // Verify that all expected providers are defined
        let provider_types: Vec<&str> = PROVIDER_CONFIGS.iter().map(|c| c.provider_type).collect();

        assert!(provider_types.contains(&"zhipu"));
        assert!(provider_types.contains(&"minimax"));
        assert!(provider_types.contains(&"kimi"));
        assert!(provider_types.contains(&"claude"));
    }

    #[test]
    fn test_find_provider_config() {
        // Test finding valid providers
        let zhipu_config = find_provider_config("zhipu");
        assert!(zhipu_config.is_some());
        let zhipu = zhipu_config.unwrap();
        assert_eq!(zhipu.provider_type, "zhipu");
        assert_eq!(zhipu.display_name, "智普LLM (Zhipu)");
        assert_eq!(zhipu.default_model, "GLM-4.6");

        let minimax_config = find_provider_config("minimax");
        assert!(minimax_config.is_some());
        let minimax = minimax_config.unwrap();
        assert_eq!(minimax.provider_type, "minimax");
        assert_eq!(minimax.display_name, "MiniMax");
        assert_eq!(minimax.default_model, "MiniMax-M2");

        // Test finding invalid provider
        let invalid_config = find_provider_config("invalid_provider");
        assert!(invalid_config.is_none());
    }

    #[test]
    fn test_get_provider_info() {
        // Test getting info for valid providers
        let (name, base_url, capabilities) = get_provider_info("zhipu");
        assert_eq!(name, "智普LLM (Zhipu)");
        assert!(base_url.contains("open.bigmodel.cn"));
        assert!(capabilities.contains(&"Chat"));
        assert!(capabilities.contains(&"Code Generation"));

        let (name, base_url, capabilities) = get_provider_info("claude");
        assert_eq!(name, "Claude (Official)");
        assert!(base_url.contains("anthropic.com"));
        assert!(capabilities.contains(&"Multimodal"));

        // Test getting info for invalid provider
        let (name, base_url, capabilities) = get_provider_info("invalid");
        assert_eq!(name, "Unknown Provider");
        assert_eq!(base_url, "");
        assert_eq!(capabilities.len(), 0);
    }

    #[test]
    fn test_get_supported_providers() {
        let providers = get_supported_providers();

        // Verify all expected providers are returned
        assert_eq!(providers.len(), 4);
        assert!(providers.contains(&"zhipu"));
        assert!(providers.contains(&"minimax"));
        assert!(providers.contains(&"kimi"));
        assert!(providers.contains(&"claude"));

        // Verify no duplicates
        let mut sorted_providers = providers.clone();
        sorted_providers.sort();
        // Note: original order may differ from sorted order, so we just check no duplicates
        assert_eq!(sorted_providers.len(), providers.len());
    }

    #[test]
    fn test_provider_config_structure() {
        let config = find_provider_config("zhipu").unwrap();

        // Verify all required fields are present
        assert!(!config.provider_type.is_empty());
        assert!(!config.display_name.is_empty());
        assert!(!config.default_model.is_empty());
        assert!(config.capabilities.len() > 0);

        // Verify auth header is set
        assert!(!config.auth_header_name.is_empty());

        // Verify capabilities are reasonable
        assert!(config.capabilities.contains(&"Chat"));
    }

    #[test]
    fn test_claude_provider_has_api_version_header() {
        let claude_config = find_provider_config("claude").unwrap();

        // Claude should have an API version header
        assert!(claude_config.api_version_header.is_some());

        let (header_name, header_value) = claude_config.api_version_header.unwrap();
        assert_eq!(header_name, "anthropic-version");
        assert_eq!(header_value, "2023-06-01");
    }

    #[test]
    fn test_non_claude_providers_no_api_version_header() {
        // Test that non-Claude providers don't have API version headers
        let zhipu_config = find_provider_config("zhipu").unwrap();
        assert!(zhipu_config.api_version_header.is_none());

        let minimax_config = find_provider_config("minimax").unwrap();
        assert!(minimax_config.api_version_header.is_none());

        let kimi_config = find_provider_config("kimi").unwrap();
        assert!(kimi_config.api_version_header.is_none());
    }

    #[test]
    fn test_provider_capabilities_consistency() {
        // Verify that all providers have reasonable capabilities
        for config in PROVIDER_CONFIGS {
            // All providers should have at least Chat capability
            assert!(config.capabilities.contains(&"Chat"),
                   "Provider {} should have Chat capability", config.provider_type);

            // Capabilities should not be empty
            assert!(config.capabilities.len() > 0,
                   "Provider {} should have at least one capability", config.provider_type);

            // All capability strings should be non-empty
            for capability in config.capabilities {
                assert!(!capability.is_empty(),
                       "Provider {} has empty capability", config.provider_type);
            }
        }
    }

    #[test]
    fn test_provider_endpoints_consistency() {
        // Verify that all providers use the expected endpoint structure
        for config in PROVIDER_CONFIGS {
            // All providers should have an endpoint
            assert!(!config.endpoint.is_empty());

            // Endpoint should start with a slash
            assert!(config.endpoint.starts_with('/'));
        }
    }
}