html-translation-lib 0.1.0

高性能HTML翻译库，专为网页本地化设计，提供智能缓存、并发批处理和内存优化功能
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! 简化的集成测试
//! 
//! 测试库的基本功能和接口

use html_translation_lib::{TranslationConfig, HtmlTranslator};

#[cfg(test)]
mod integration_tests {
    use super::*;

    #[tokio::test]
    async fn test_translator_creation() {
        // 测试翻译器能够成功创建
        let config = TranslationConfig::new()
            .target_language("zh")
            .api_url("http://mock-service.com/translate")
            .enable_cache(false);
        
        let translator = HtmlTranslator::new(config).await;
        assert!(translator.is_ok());
    }

    #[tokio::test]
    async fn test_config_validation() {
        // 测试配置验证
        let valid_config = TranslationConfig::new()
            .target_language("en")
            .api_url("http://example.com");
        
        assert!(valid_config.validate().is_ok());
        
        // 测试无效配置
        let invalid_config = TranslationConfig::new()
            .target_language("")  // 空的目标语言
            .api_url("http://example.com");
        
        assert!(invalid_config.validate().is_err());
    }

    #[tokio::test]
    async fn test_html_parsing() {
        // 测试HTML解析功能（不实际调用翻译API）
        let config = TranslationConfig::new()
            .target_language("zh")
            .api_url("http://mock-service.com/translate")
            .enable_cache(false);
        
        let mut translator = HtmlTranslator::new(config).await.unwrap();
        
        let simple_html = "<html><body><h1>Test</h1></body></html>";
        
        // 这个测试会失败（因为Mock服务不存在），但我们主要测试解析不会崩溃
        let result = translator.translate_html(simple_html).await;
        
        // 验证返回的是网络错误而不是解析错误
        if let Err(error) = result {
            // 错误应该是网络相关的，而不是HTML解析错误
            assert!(!error.to_string().contains("HTML解析错误"));
        }
    }

    #[test]
    fn test_library_info() {
        use html_translation_lib::get_library_info;
        
        let info = get_library_info();
        assert_eq!(info.name, "html-translation-lib");
        assert_eq!(info.version, "0.1.0");
        
        // 验证至少有一个特性启用
        assert!(!info.features.is_empty());
    }

    #[test]
    fn test_error_types() {
        use html_translation_lib::TranslationError;
        
        let service_error = TranslationError::service_error("test");
        assert!(service_error.is_retryable());
        
        let config_error = TranslationError::config_error("test");
        assert!(!config_error.is_retryable());
        
        let network_error = TranslationError::network_error("test");
        assert!(network_error.is_retryable());
    }

    #[test]
    fn test_translation_stats() {
        use html_translation_lib::core::TranslationStats;
        
        let mut stats = TranslationStats::default();
        stats.cache_hits = 8;
        stats.cache_misses = 2;
        
        assert_eq!(stats.cache_hit_rate(), 0.8);
        
        stats.texts_filtered = 100;
        stats.batches_created = 5;
        
        assert_eq!(stats.average_batch_size(), 20.0);
    }

    #[cfg(feature = "sync")]
    #[test]
    fn test_sync_interface_exists() {
        // 只测试同步接口是否存在，不实际调用网络
        use html_translation_lib::translate_html_content_sync;
        
        let result = translate_html_content_sync(
            "<p>test</p>",
            "zh", 
            Some("http://nonexistent.invalid/translate")
        );
        
        // 由于使用了无效的URL，应该会有错误
        if let Err(error) = result {
            // 验证错误类型是网络相关的
            assert!(error.to_string().contains("网络") || error.to_string().contains("服务") || error.to_string().contains("超时"));
        } else {
            // 如果成功了，也是合理的（可能是返回了原始内容）
            // 这里主要是验证函数可以调用
        }
    }
}